@@ -24,6 +24,9 @@
   Windows.
 - `ignore` patterns follow the `windowsPathsNoEscape` option,
   the same as other patterns.
+- On Windows, patterns that start with a long UNC root like
+  `//?/UNC/host/share/` walk that share, the same as
+  `//host/share/`.
 - Faster `ignore` patterns (about 1.2 to 3 times faster), and
   less work for each entry in a walk (about 10% faster sync, and
   15% to 30% faster async, for large trees).
 
@@ -80,19 +80,24 @@ export class Pattern {
       // //host/share => ['//host/share/']
       // //host/share/ => ['//host/share/']
       // //host/share/x => ['//host/share/', 'x']
+      // //?/UNC/host/share/x => ['//?/UNC/host/share/', 'x']
       // /etc => ['/', 'etc']
       // / => ['/']
       if (this.isUNC()) {
-        // '' / '' / 'host' / 'share'
-        const [p0, p1, p2, p3, ...prest] = this.#patternList
-        const [g0, g1, g2, g3, ...grest] = this.#globList
+        // '' / '' / 'host' / 'share', or
+        // '' / '' / '?' / 'UNC' / 'host' / 'share'
+        const n = this.#isLongUNC() ? 6 : 4
+        const proot = this.#patternList.slice(0, n)
+        const groot = this.#globList.slice(0, n)
+        const prest = this.#patternList.slice(n)
+        const grest = this.#globList.slice(n)
         if (prest[0] === '') {
           // ends in /
           prest.shift()
           grest.shift()
         }
-        const p = [p0, p1, p2, p3, ''].join('/')
-        const g = [g0, g1, g2, g3, ''].join('/')
+        const p = [...proot, ''].join('/')
+        const g = [...groot, ''].join('/')
         this.#patternList = [p, ...prest]
         this.#globList = [g, ...grest]
         this.length = this.#patternList.length
@@ -181,22 +186,32 @@ export class Pattern {
     return this.#rest
   }
 
+  // the root is //?/UNC/host/share, the same as //host/share
+  #isLongUNC(): boolean {
+    const pl = this.#patternList
+    return (
+      pl[2] === '?' && typeof pl[3] === 'string' && /^unc$/i.test(pl[3])
+    )
+  }
+
   /**
    * true if the pattern represents a //unc/path/ on windows
    */
   isUNC(): boolean {
     const pl = this.#patternList
+    // the host and share, after //?/UNC/ in a long UNC path
+    const h = this.#isLongUNC() ? 4 : 2
     return this.#isUNC !== undefined ?
         this.#isUNC
       : (this.#isUNC =
           this.#platform === 'win32' &&
           this.#index === 0 &&
           pl[0] === '' &&
           pl[1] === '' &&
-          typeof pl[2] === 'string' &&
-          !!pl[2] &&
-          typeof pl[3] === 'string' &&
-          !!pl[3])
+          typeof pl[h] === 'string' &&
+          !!pl[h] &&
+          typeof pl[h + 1] === 'string' &&
+          !!pl[h + 1])
   }
 
   // pattern like C:/...
 
@@ -0,0 +1,65 @@
+// //?/UNC/host/share/x is the same path as //host/share/x on Windows
+
+import * as fs from 'fs'
+import { PathScurryWin32 } from 'path-scurry'
+import t from 'tap'
+import { glob, globSync } from '../dist/esm/index.js'
+
+const dir = t.testdir({
+  a: { x: '', y: '' },
+  b: { x: '' },
+})
+
+// serve \\HOST\SHARE\ from the test dir
+const real = (p: string) =>
+  p.replace(/^\\\\HOST\\SHARE\\?/i, `${dir}/`).replace(/\\/g, '/')
+const winfs = {
+  lstatSync: (p: string) => fs.lstatSync(real(p)),
+  readdir: (
+    p: string,
+    o: { withFileTypes: true },
+    cb: (er: NodeJS.ErrnoException | null, e?: fs.Dirent[]) => any,
+  ) => fs.readdir(real(p), o, cb),
+  readdirSync: (p: string, o: { withFileTypes: true }) =>
+    fs.readdirSync(real(p), o),
+  readlinkSync: (p: string) => fs.readlinkSync(real(p)),
+  realpathSync: (p: string) => fs.realpathSync(real(p)),
+  promises: {
+    lstat: (p: string) => fs.promises.lstat(real(p)),
+    readdir: (p: string, o: { withFileTypes: true }) =>
+      fs.promises.readdir(real(p), o),
+    readlink: (p: string) => fs.promises.readlink(real(p)),
+    realpath: (p: string) => fs.promises.realpath(real(p)),
+  },
+}
+
+// the share is a new root, which uses the same fs as the cwd
+const scurry = () => new PathScurryWin32('C:\\', { fs: winfs })
+
+const expect = ['//HOST/SHARE/a/x', '//HOST/SHARE/b/x']
+for (const pattern of [
+  '//host/share/*/x',
+  '//?/UNC/host/share/*/x',
+  '//?/unc/HOST/share/*/x',
+  '//?/UNC/host/share/a/../*/x',
+]) {
+  t.test(pattern, async t => {
+    const opts = {
+      platform: 'win32',
+      posix: true,
+      scurry: scurry(),
+    } as const
+    t.strictSame(globSync(pattern, opts).sort(), expect, 'sync')
+    t.strictSame((await glob(pattern, opts)).sort(), expect, 'async')
+  })
+}
+
+t.test('ignore', async t => {
+  const opts = {
+    platform: 'win32',
+    posix: true,
+    scurry: scurry(),
+    ignore: ['//?/UNC/host/share/a/**'],
+  } as const
+  t.strictSame(globSync('//host/share/*/x', opts), ['//HOST/SHARE/b/x'])
+})
@@ -16,6 +16,9 @@ t.same(
       '//?/z:',
       'c:/x/*',
       'c:/',
+      '//?/UNC/host/share/x/*',
+      '//?/unc/host/share/',
+      '//?/UNC/host/share',
     ],
     { platform: 'win32' },
   ).patterns.map(p => [p.globString(), p.root()]),
@@ -28,6 +31,9 @@ t.same(
     ['//?/z:/', '//?/z:/'],
     ['c:/x/*', 'c:/'],
     ['c:/', 'c:/'],
+    ['//?/UNC/host/share/x/*', '//?/UNC/host/share/'],
+    ['//?/unc/host/share/', '//?/UNC/host/share/'],
+    ['//?/UNC/host/share/', '//?/UNC/host/share/'],
   ],
 )
 t.throws(() => {