rvlib-shipkit 1.6.0 → 1.8.0

package/src/suite/select.ts

@@ -0,0 +1,510 @@
+// THE QUICK TIER RUNS ONLY THE SUITES A CHANGE CAN REACH. A run leaves the
+// snapshot of the work tree it started from (every file's git blob id) and the
+// suites it ran that did not pass, the DIRTY ones. The next quick run diffs the
+// disk against that snapshot, and runs every dirty suite plus every suite that
+// depends on something in the diff:
+//
+//   - its static import closure, json and `?raw` text included, and the
+//     closure of every preload, which each suite loads first;
+//   - what any module of that closure READ at runtime, as the read recorder
+//     charged it (suite-reads-preload.ts): a file, a listing, a walked tree;
+//   - the modules a module of that closure imported at runtime that no
+//     static import names (a computed import).
+//
+// Why that holds: a suite that is not dirty passed on a tree where everything
+// it depends on was as it is in the snapshot, so a diff that reaches none of
+// it cannot change its verdict. A suite red in a shared tree stays dirty and
+// runs every time, while every other suite moves on.
+//
+// A suite also runs when it has never run under the recorder, when its
+// closure holds a module that spawned a process nobody records, and every
+// suite runs when there is no snapshot yet, when a file that configures the
+// run changed (bunfig, package.json, the lockfile, a tsconfig, the env file),
+// or when this file's format moved. When the selection is unsure it runs
+// more, never less. The full tier runs everything and replaces the reads.
+import { createHash } from 'crypto'
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync } from 'fs'
+import { dirname, join, posix, relative, resolve, sep } from 'path'
+import { atomicWrite } from '../core/locked-write.ts'
+import { gitBin } from '../core/git-bin.ts'
+import { blobOid, listingHash } from '../core/read-set.ts'
+import { shipkitRoot } from '../ledger/db.ts'
+import { extractSpecs, resolveSpec } from '../ts/source-graph.ts'
+import { type RvtConfig } from '../ts/config.ts'
+
+export const SELECT_VERSION = 5
+
+/** what the recorder charged to one module, repo-relative: r a file read, d a
+ *  dir listed, g a tree walked, o a spawn nobody records, l a module loaded at
+ *  runtime from a call this module was on the stack of, L one loaded while
+ *  this module itself was being loaded */
+export type ModuleReads = { r?: string[]; d?: string[]; g?: string[]; o?: string[]; l?: string[]; L?: string[] }
+
+/** one parsed source: its stat signature and the repo files it imports. An
+ *  `import.meta.glob` is no edge: bun has none, so no suite that passes ran one */
+export type GraphEntry = { sig: string; deps: string[] }
+
+export type SelectState = {
+    version: number
+    /** path → blob id (or a listing hash) the last run started from, null before one */
+    base: Record<string, string> | null
+    /** suites the last run picked that did not pass (red, killed, over the budget, or never reached) */
+    dirty: string[]
+    /** module → what it read in any recorded run since the last full one */
+    modules: Record<string, ModuleReads>
+    /** suites that ran under the recorder at least once */
+    recorded: string[]
+    /** the parse of every source the graph walked, by stat signature */
+    graph: Record<string, GraphEntry>
+    /** the bun that ran the last run: another one runs every suite */
+    bun?: string
+}
+
+export const emptyState = (): SelectState => ({ version: SELECT_VERSION, base: null, dirty: [], modules: {}, recorded: [], graph: {} })
+
+/** where one checkout keeps its selection state: per work tree, since each
+ *  holds its own files, beside the rest of what the repo remembers */
+export function selectStatePath(top: string, unit: string): string {
+    const id = createHash('sha256').update(resolve(top)).digest('hex').slice(0, 12)
+    return join(shipkitRoot(top), 'suite-select', id, `${unit === '' ? 'root' : unit}.json`)
+}
+
+export function loadState(path: string): SelectState {
+    try {
+        const s = JSON.parse(readFileSync(path, 'utf8')) as SelectState
+        if (s.version !== SELECT_VERSION || typeof s.modules !== 'object' || !Array.isArray(s.recorded) || !Array.isArray(s.dirty)) return emptyState()
+        return { ...emptyState(), ...s }
+    } catch {
+        return emptyState()
+    }
+}
+
+export function saveState(path: string, s: SelectState): void {
+    mkdirSync(dirname(path), { recursive: true })
+    atomicWrite(path, JSON.stringify(s))
+}
+
+// ---------------------------------------------------------------------------
+// the static graph
+
+const CODE = /\.(?:[cm]?[jt]sx?)$/
+const statSig = (abs: string): string | null => {
+    try {
+        const st = statSync(abs)
+        return st.isFile() ? `${st.size}:${st.mtimeMs}:${st.ctimeMs}` : null
+    } catch {
+        return null
+    }
+}
+
+/** parse one file, from the manifest when its stat signature held */
+function entryOf(cfg: RvtConfig, file: string, old: GraphEntry | undefined): GraphEntry | null {
+    const abs = join(cfg.root, file)
+    const sig = statSig(abs)
+    if (sig == null) return null
+    if (old != null && old.sig === sig) return old
+    // a symlink loads its target
+    let link: string[] = []
+    try {
+        if (lstatSync(abs).isSymbolicLink()) {
+            const t = relative(cfg.root, realpathSync(abs)).split(sep).join('/')
+            if (!t.startsWith('..') && t !== file) link = [t]
+        }
+    } catch { /* gone between the stat and here: no edge */ }
+    if (!CODE.test(file)) return { sig, deps: link }
+    let text: string
+    try { text = readFileSync(abs, 'utf8') } catch { return null }
+    const has = (p: string): boolean => statSig(join(cfg.root, p)) != null
+    const deps = new Set<string>()
+    // only what LOADING the module runs: a require or an import() in a body
+    // runs when called, and the recorder sees it then, with who called
+    for (const raw of extractSpecs(text, { dynamic: false })) {
+        const spec = raw.replace(/\?.*$/, '')
+        const target = resolveSpec(cfg, file, spec, has)
+        if (target != null && target !== file) deps.add(target)
+    }
+    return { sig, deps: [...new Set([...deps, ...link])].sort() }
+}
+
+/** every file the entries reach by import, parsed through the manifest. The
+ *  returned map is the new manifest: only what this walk reached */
+export function walkGraph(cfg: RvtConfig, entries: string[], manifest: Record<string, GraphEntry>): Record<string, GraphEntry> {
+    const out: Record<string, GraphEntry> = {}
+    const todo = [...entries]
+    while (todo.length > 0) {
+        const f = todo.pop()!
+        if (out[f] != null) continue
+        const e = entryOf(cfg, f, manifest[f])
+        if (e == null) continue
+        out[f] = e
+        for (const d of e.deps) if (out[d] == null) todo.push(d)
+    }
+    return out
+}
+
+export function closureOf(graph: Record<string, GraphEntry>, entries: Iterable<string>): Set<string> {
+    const seen = new Set<string>()
+    const todo = [...entries]
+    while (todo.length > 0) {
+        const f = todo.pop()!
+        if (seen.has(f)) continue
+        seen.add(f)
+        for (const d of graph[f]?.deps ?? []) if (!seen.has(d)) todo.push(d)
+    }
+    return seen
+}
+
+// ---------------------------------------------------------------------------
+// the snapshot
+
+/** keys of a listing and of a walked tree, beside the file paths */
+export const listKey = (dir: string): string => `${dir === '.' ? '' : dir}/`
+export const treeKey = (dir: string): string => `${dir === '.' ? '' : dir}/**`
+
+function git(top: string, args: string[]): string {
+    const p = Bun.spawnSync([gitBin(), '--no-optional-locks', ...args], { cwd: top, stdout: 'pipe', stderr: 'pipe' })
+    if (p.exitCode !== 0) throw new Error(`git ${args.join(' ')} exited ${p.exitCode}: ${p.stderr.toString().trim().split('\n')[0]}`)
+    return p.stdout.toString()
+}
+
+const listing = (abs: string, deep: boolean): string | null => {
+    const names: string[] = []
+    const walk = (dir: string, pre: string): boolean => {
+        let entries
+        try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return false }
+        for (const e of entries) {
+            if (e.name === 'node_modules' || e.name === '.git') continue
+            names.push(`${pre}${e.name}${e.isDirectory() ? '/' : ''}`)
+            if (deep && e.isDirectory()) walk(join(dir, e.name), `${pre}${e.name}/`)
+        }
+        return true
+    }
+    if (!walk(abs, '')) return null
+    return listingHash(names.sort())
+}
+
+/** the work tree as blob ids: what git tracks or would add (one ls-files and
+ *  one status, no index write), every recorded read git does not see, and a
+ *  hash of every recorded listing and walked tree */
+export function snapshot(top: string, modules: Record<string, ModuleReads>): Record<string, string> {
+    const snap: Record<string, string> = {}
+    for (const line of git(top, ['ls-files', '-s', '-z']).split('\0')) {
+        const tab = line.indexOf('\t')
+        if (tab < 0) continue
+        snap[line.slice(tab + 1)] = line.split(' ')[1]!
+    }
+    const status = git(top, ['status', '--porcelain=v1', '-z', '-uall', '--no-renames', '--ignore-submodules']).split('\0')
+    for (const entry of status) {
+        if (entry.length < 4) continue
+        const path = entry.slice(3)
+        const abs = join(top, path)
+        try {
+            const st = statSync(abs)
+            if (st.isFile()) snap[path] = blobOid(readFileSync(abs))
+            else delete snap[path]
+        } catch {
+            delete snap[path]
+        }
+    }
+    return { ...snap, ...extras(top, modules, snap) }
+}
+
+/** the recorded reads git does not see, and every recorded listing and walked
+ *  tree, keyed beside the file paths. `since`: leave out a key whose path
+ *  moved after that instant, since what a run read may then be either form */
+export function extras(top: string, modules: Record<string, ModuleReads>, have: Record<string, string>, since?: number): Record<string, string> {
+    const out: Record<string, string> = {}
+    const moved = (abs: string): boolean => {
+        if (since == null) return false
+        try {
+            const st = statSync(abs)
+            return st.mtimeMs > since || st.ctimeMs > since
+        } catch {
+            return false
+        }
+    }
+    const reads = new Set<string>()
+    const lists = new Set<string>()
+    const trees = new Set<string>()
+    for (const m of Object.values(modules)) {
+        for (const r of m.r ?? []) reads.add(r)
+        for (const d of m.d ?? []) lists.add(d)
+        for (const g of m.g ?? []) trees.add(g)
+    }
+    for (const r of reads) {
+        if (r === '.' || have[r] != null) continue
+        const abs = join(top, r)
+        if (moved(abs)) continue
+        try {
+            const st = statSync(abs)
+            out[r] = st.isFile() ? blobOid(readFileSync(abs)) : st.isDirectory() ? 'dir' : 'other'
+        } catch {
+            out[r] = 'absent'
+        }
+    }
+    for (const d of lists) if (have[listKey(d)] == null && !moved(join(top, d))) out[listKey(d)] = listing(join(top, d), false) ?? 'absent'
+    for (const g of trees) if (have[treeKey(g)] == null && !moved(join(top, g))) out[treeKey(g)] = listing(join(top, g), true) ?? 'absent'
+    return out
+}
+
+/** the keys whose value differs, one side missing included */
+export function changedKeys(before: Record<string, string>, now: Record<string, string>): Set<string> {
+    const out = new Set<string>()
+    for (const [k, v] of Object.entries(now)) if (before[k] !== v) out.add(k)
+    for (const k of Object.keys(before)) if (now[k] == null) out.add(k)
+    return out
+}
+
+// ---------------------------------------------------------------------------
+// the recorder's lines
+
+/** the recorder's lines folded into the module reads */
+export function foldReads(base: Record<string, ModuleReads>, text: string): Record<string, ModuleReads> {
+    const sets = new Map<string, Map<string, Set<string>>>()
+    const at = (mod: string, kind: string): Set<string> => {
+        let m = sets.get(mod)
+        if (m == null) sets.set(mod, (m = new Map()))
+        let s = m.get(kind)
+        if (s == null) m.set(kind, (s = new Set()))
+        return s
+    }
+    for (const [mod, reads] of Object.entries(base)) for (const [kind, list] of Object.entries(reads)) for (const p of list as string[]) at(mod, kind).add(p)
+    for (const line of text.split('\n')) {
+        const [kind, mod, path] = line.split('\t')
+        if (kind == null || mod == null || path == null || !['r', 'd', 'g', 'o', 'l', 'L'].includes(kind)) continue
+        at(mod, kind).add(path)
+    }
+    const out: Record<string, ModuleReads> = {}
+    for (const [mod, kinds] of [...sets].sort(([a], [b]) => (a < b ? -1 : 1))) {
+        const r: ModuleReads = {}
+        for (const [kind, s] of kinds) (r as Record<string, string[]>)[kind] = [...s].sort()
+        out[mod] = r
+    }
+    return out
+}
+
+/** the runtime import edges a static import already names carry nothing */
+export function dropStaticEdges(modules: Record<string, ModuleReads>, graph: Record<string, GraphEntry>): Record<string, ModuleReads> {
+    const out: Record<string, ModuleReads> = {}
+    for (const [m, r] of Object.entries(modules)) {
+        const known = new Set(graph[m]?.deps ?? [])
+        const kept: ModuleReads = { ...r }
+        for (const k of ['l', 'L'] as const) {
+            const left = (r[k] ?? []).filter((p) => !known.has(p))
+            if (left.length > 0) kept[k] = left
+            else delete kept[k]
+        }
+        if (Object.keys(kept).length > 0) out[m] = kept
+    }
+    return out
+}
+
+// ---------------------------------------------------------------------------
+// the selection
+
+export type Selection =
+    | { all: true; why: string }
+    | { all: false; run: string[]; why: Map<string, string>; changed: number }
+
+/** files whose change moves every suite: they configure the run itself */
+export const isRunConfig = (path: string, envFiles: string[]): boolean =>
+    /(^|\/)(bunfig\.toml|package\.json|bun\.lockb?|tsconfig(\.[^/]*)?\.json|repo\.config\.ts)$/.test(path) || envFiles.includes(path)
+
+/** a file bun's test runner runs: `*.test.*`, `*_test.*`, `*.spec.*`, `*_spec.*` in js or ts */
+export const isBunSuite = (path: string): boolean => /[._](test|spec)\.[cm]?[jt]sx?$/.test(path)
+
+export function selectSuites(o: {
+    suites: string[]
+    preloads: string[]
+    envFiles: string[]
+    graph: Record<string, GraphEntry>
+    modules: Record<string, ModuleReads>
+    recorded: Set<string>
+    dirty?: Set<string>
+    changed: Set<string>
+    /** the dirs a suite reads code and fixtures from: a change there that no
+     *  import and no recorded read claims runs every suite */
+    roots?: string[]
+}): Selection {
+    for (const c of o.changed) if (isRunConfig(c, o.envFiles)) return { all: true, why: `${c} changed, and it configures every suite` }
+    // the recorder sees only what it hooks (a preload's own load, a tool it
+    // does not know, an API it does not wrap go unseen), so a change where
+    // suites live that nothing claims is unsure, and unsure runs everything
+    const lists = new Set<string>()
+    const trees: string[] = []
+    const readSet = new Set<string>()
+    for (const r of Object.values(o.modules)) {
+        for (const p of r.r ?? []) readSet.add(p)
+        for (const p of [...(r.l ?? []), ...(r.L ?? [])]) readSet.add(p)
+        for (const d of r.d ?? []) lists.add(d)
+        for (const g of r.g ?? []) trees.push(g === '.' ? '' : `${g}/`)
+    }
+    const claimed = (c: string): boolean =>
+        c.endsWith('/') || c.endsWith('/**') || o.graph[c] != null || readSet.has(c) || lists.has(posix.dirname(c)) || trees.some((t) => c.startsWith(t))
+    const under = (c: string): boolean => (o.roots ?? []).some((r) => r === '' || r === '.' || c.startsWith(`${r}/`))
+    for (const c of o.changed) if (!claimed(c) && under(c)) return { all: true, why: `${c} changed, and neither an import nor a recorded read claims it` }
+    // a changed file moves every module that loads it with itself, and one a
+    // preload loads moves every suite: the preload ran it before any suite
+    const importersOf = (withRuntime: boolean): Map<string, string[]> => {
+        const out = new Map<string, string[]>()
+        const add = (f: string, d: string): void => { out.set(d, [...(out.get(d) ?? []), f]) }
+        for (const [f, e] of Object.entries(o.graph)) for (const d of e.deps) add(f, d)
+        for (const [m, r] of Object.entries(o.modules)) {
+            for (const d of r.L ?? []) add(m, d)
+            if (withRuntime) for (const d of r.l ?? []) add(m, d)
+        }
+        return out
+    }
+    const spread = (seeds: Map<string, string>, importers: Map<string, string[]>, fence: Set<string>): Map<string, string> => {
+        const why = new Map<string, string>()
+        const todo: string[] = []
+        for (const [m, w] of seeds) if (!why.has(m)) { why.set(m, w); todo.push(m) }
+        while (todo.length > 0) {
+            const f = todo.pop()!
+            for (const i of importers.get(f) ?? []) {
+                if (why.has(i) || fence.has(i)) continue
+                why.set(i, why.get(f)!)
+                todo.push(i)
+            }
+        }
+        return why
+    }
+    const changedSeeds = new Map([...o.changed].map((c) => [c, `${c} changed`]))
+    const statically = spread(changedSeeds, importersOf(false), new Set())
+    const preHit = o.preloads.find((p) => statically.has(p))
+    if (preHit != null) return { all: true, why: `${statically.get(preHit)!}, and every suite loads ${preHit} first` }
+    // a module whose read changed, and every module that loaded a changed file
+    // at runtime, moves its importers, but never through a preload: the
+    // recorder charged a read or a lazy load inside a hook a preload installed
+    // to every module on the stack, the one that asked included
+    // a listing runs its reader when a file in that dir changes too: what lists
+    // a dir mostly opens what it found, and an image library or a database
+    // opens it where no recorder sees
+    const changedDirs = new Set([...o.changed].map((c) => posix.dirname(c)))
+    const reads = new Map<string, string>()
+    for (const [m, r] of Object.entries(o.modules)) {
+        if ((r.o ?? []).length > 0) { reads.set(m, `${m} spawns ${r.o![0]}, whose reads nobody records`); continue }
+        const read = (r.r ?? []).find((p) => o.changed.has(p))
+            ?? (r.d ?? []).find((d) => o.changed.has(listKey(d)) || changedDirs.has(d))
+            ?? (r.g ?? []).find((g) => o.changed.has(treeKey(g)) || [...o.changed].some((c) => g === '.' || c.startsWith(`${g}/`)))
+        if (read != null) reads.set(m, `${m} reads ${read}, which changed`)
+    }
+    if (reads.has('-')) return { all: true, why: reads.get('-')!.replace(/^- reads/, 'a read no module owns:') }
+    const why = spread(new Map([...statically, ...reads]), importersOf(true), new Set(o.preloads))
+    const run: string[] = []
+    const reasons = new Map<string, string>()
+    for (const s of o.suites) {
+        const w = !o.recorded.has(s) ? 'it never ran under the read recorder' : o.dirty?.has(s) === true ? 'it did not pass last time' : why.get(s)
+        if (w == null) continue
+        run.push(s)
+        reasons.set(s, w)
+    }
+    return { all: false, run, why: reasons, changed: o.changed.size }
+}
+
+const BETWEEN_TESTS = '# Unhandled error between tests'
+const RULE = /^-{20,}$/
+
+/** the repo modules named in the frames of every error bun printed between
+ *  tests (a module whose top level threw), repo-relative to `top` */
+export function loadErrorModules(out: string, top: string): string[] {
+    const abs = resolve(top)
+    const roots = [abs, abs.startsWith('/private/') ? abs.slice('/private'.length) : `/private${abs}`]
+    const found = new Set<string>()
+    const lines = out.split('\n')
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i]!.trim() !== BETWEEN_TESTS) continue
+        // the block: a rule, the frames, a closing rule
+        let rules = 0
+        for (let j = i + 1; j < lines.length && rules < 2; j++) {
+            const line = lines[j]!
+            if (RULE.test(line.trim())) { rules++; continue }
+            const m = /^\s+at .*?\(?((?:\/|[A-Za-z]:\\)[^():]+):\d+(?::\d+)?\)?\s*$/.exec(line)
+            if (m == null) continue
+            const base = roots.find((r) => m[1]!.startsWith(`${r}/`))
+            if (base == null) continue
+            const rel = relative(base, m[1]!).split(sep).join('/')
+            if (!rel.split('/').includes('node_modules')) found.add(rel)
+        }
+    }
+    return [...found].sort()
+}
+
+/** the picked suites a module that threw while loading leaves untrusted:
+ *  every one that loads it, statically or at runtime */
+export function taintedSuites(picked: string[], thrown: string[], graph: Record<string, GraphEntry>, modules: Record<string, ModuleReads>, preloads: string[]): Set<string> {
+    if (thrown.length === 0) return new Set()
+    // a broken module poisons only what LOADS it: reads and spawns carry nothing here
+    const loads: Record<string, ModuleReads> = {}
+    for (const [m, r] of Object.entries(modules)) if (r.l != null || r.L != null) loads[m] = { ...(r.l != null ? { l: r.l } : {}), ...(r.L != null ? { L: r.L } : {}) }
+    const sel = selectSuites({ suites: picked, preloads, envFiles: [], graph, modules: loads, recorded: new Set(picked), changed: new Set(thrown) })
+    return new Set(sel.all ? picked : sel.run)
+}
+
+/** the preloads a bunfig and a command line hand every suite, repo-relative
+ *  to `top`. `cwd` is where bun runs */
+export function preloadsOf(bunfigText: string | null, rawArgs: string[], cwdRel: string): string[] {
+    const out: string[] = []
+    const add = (p: unknown): void => {
+        if (typeof p !== 'string') return
+        out.push(posix.normalize(posix.join(cwdRel, p)))
+    }
+    if (bunfigText != null) {
+        try {
+            const t = Bun.TOML.parse(bunfigText) as { preload?: unknown; test?: { preload?: unknown } }
+            for (const p of [t.preload, t.test?.preload]) (Array.isArray(p) ? p : [p]).forEach(add)
+        } catch { /* the runner reports an unparseable bunfig */ }
+    }
+    for (let i = 0; i < rawArgs.length; i++) {
+        const a = rawArgs[i]!
+        if (a === '--preload' || a === '-r') add(rawArgs[++i])
+        else if (a.startsWith('--preload=')) add(a.slice('--preload='.length))
+    }
+    return out
+}
+
+/** the env files a command line names (`--env-file`) */
+export function envFilesOf(rawArgs: string[], cwdRel: string): string[] {
+    const out: string[] = []
+    for (let i = 0; i < rawArgs.length; i++) {
+        const a = rawArgs[i]!
+        const v = a === '--env-file' ? rawArgs[++i] : a.startsWith('--env-file=') ? a.slice('--env-file='.length) : null
+        if (v != null) out.push(posix.normalize(posix.join(cwdRel, v)))
+    }
+    return out
+}
+
+/** the test files bun would run here: tracked or new, under `testRoot`,
+ *  outside every ignore pattern, cwd-relative */
+export function suiteFiles(top: string, cwdRel: string, testRoot: string | null, ignores: string[], isTest: (f: string) => boolean): string[] {
+    const under = posix.normalize(posix.join(cwdRel, testRoot ?? '.'))
+    const at = under === '.' ? '.' : under
+    // bun discovers what git ignores too, an install excepted
+    const listed = [
+        ...git(top, ['ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', at]).split('\0'),
+        ...git(top, ['ls-files', '-z', '--others', '--ignored', '--exclude-standard', '--', at]).split('\0').filter((f) => !f.split('/').includes('node_modules')),
+    ]
+    const res = ignores.map((g) => globRe(g))
+    const out: string[] = []
+    for (const f of listed) {
+        if (f === '' || !isTest(f) || !existsSync(join(top, f))) continue
+        const rel = cwdRel === '' || cwdRel === '.' ? f : f.slice(cwdRel.length + 1)
+        if (res.some((re) => re.test(rel))) continue
+        out.push(rel)
+    }
+    return [...new Set(out)].sort()
+}
+
+/** a bun ignore pattern as a regexp: `**` any depth, `*` one segment */
+export function globRe(glob: string): RegExp {
+    const g = glob.replace(/^\.\//, '')
+    let re = ''
+    for (let i = 0; i < g.length; i++) {
+        const c = g[i]!
+        if (c === '*' && g[i + 1] === '*') { re += '.*'; i++; if (g[i + 1] === '/') i++ }
+        else if (c === '*') re += '[^/]*'
+        else if (c === '?') re += '[^/]'
+        else re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    }
+    return new RegExp(`^${re}$`)
+}