@orkestrel/scaffold 0.0.102 → 0.0.104

package/dist/agents/skills/orkestrel-dispatch/scripts/helpers.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 /** Names the directories every tree walk in a skill script skips. */
 export const SKIPPED_DIRECTORIES = new Set([
@@ -10,6 +10,89 @@ export const SKIPPED_DIRECTORIES = new Set([
     '.orkestrel',
     '.idea',
 ]);
+/** Names the manifest fields that hold specs, including nested overrides. */
+export const SPEC_FIELDS = Object.freeze([
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+    'overrides',
+]);
+/** Matches npm local prefixes and path starts, including drive-relative paths. */
+export const LOCAL_SPEC_PATTERN = /^(?:file:|link:|\.|~[\\/]|[\\/]|[A-Za-z]:)/iu;
+/** Matches archive specs with no protocol and a tgz, tar.gz, or tar extension. */
+export const ARCHIVE_SPEC_PATTERN = /^[^:]+\.(?:tgz|tar\.gz|tar)$/iu;
+/** Matches hosted user/repository shorthand even when its name ends in an archive extension. */
+export const SHORTHAND_SPEC_PATTERN = /^[^:@%/\s.-][^:@%/\s]*\/[^:@\s/%]+$/u;
+/**
+ * Checks whether a value is a non-null, non-array object.
+ *
+ * @param value - The value to inspect.
+ * @returns True if the value is an object other than null or an array; false otherwise.
+ * @example
+ * isRecord({ dependencies: {} }) // true
+ * isRecord([]) // false
+ */
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Checks whether npm resolves a spec from the local host.
+ *
+ * @param spec - The package spec, with leading whitespace ignored.
+ * @returns True if the spec names a local path or archive; false otherwise.
+ * @example
+ * matchesLocalSpec('file:../other') // true
+ * matchesLocalSpec('owner/package.tgz') // false
+ */
+export function matchesLocalSpec(spec) {
+    const text = spec.trimStart();
+    return (LOCAL_SPEC_PATTERN.test(text) ||
+        (ARCHIVE_SPEC_PATTERN.test(text) && !SHORTHAND_SPEC_PATTERN.test(text)));
+}
+/**
+ * Collects string specs with the dotted path of each nested record member.
+ *
+ * @param path - The field path that prefixes each finding.
+ * @param value - A string or finite, acyclic manifest record; other values contribute no specs.
+ * @returns The path and spec pairs in record order.
+ * @example
+ * collectSpecs('overrides', { a: { b: 'file:../other' } })
+ * // [['overrides.a.b', 'file:../other']]
+ */
+export function collectSpecs(path, value) {
+    if (typeof value === 'string')
+        return [[path, value]];
+    if (!isRecord(value))
+        return [];
+    return Object.entries(value).flatMap(([key, child]) => collectSpecs(`${path}.${key}`, child));
+}
+/**
+ * Finds local specs in the manifest's spec fields, including nested overrides.
+ *
+ * @param manifest - A finite, acyclic package manifest record.
+ * @returns Each local spec's dotted field path and spec, in field and record order.
+ * @example
+ * scanLocalSpecs({ overrides: { a: { b: 'file:../other' } } })
+ * // [['overrides.a.b', 'file:../other']]
+ */
+export function scanLocalSpecs(manifest) {
+    return SPEC_FIELDS.flatMap((field) => collectSpecs(field, manifest[field]).filter(([, spec]) => matchesLocalSpec(spec)));
+}
+/**
+ * Removes a tree with bounded retries for transient host removal errors.
+ *
+ * @param path - The directory to remove; a missing path succeeds.
+ * @returns Nothing after the removal succeeds.
+ * @throws Thrown when removal fails after the bounded retries or the host refuses the path.
+ * @remarks
+ * Uses Node's recursive removal with five retries and a 100 ms retry delay.
+ * @example
+ * removeTree(scratch.path)
+ */
+export function removeTree(path) {
+    rmSync(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+}
 /**
  * Reads the value that follows a flag.
  *

package/dist/agents/skills/orkestrel-dispatch/scripts/launch.js

@@ -41,6 +41,18 @@ function killTree(pid) {
     }
     catch { }
 }
+function startCommand(command, args, journal, errors) {
+    try {
+        return spawn(command, args, { stdio: ['ignore', journal, errors], windowsHide: true });
+    }
+    catch (error) {
+        return {
+            code: null,
+            signal: null,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 function waitForExit(child) {
     return new Promise((resolve) => {
         child.on('error', (error) => resolve({ code: null, signal: null, error: error.message }));
@@ -79,21 +91,24 @@ async function main(argv) {
     const errorsFd = openSync(errors, 'w');
     rmSync(`${journal}.pid`, { force: true });
     const started = Date.now();
-    const child = spawn(command, args, { stdio: ['ignore', journalFd, errorsFd], windowsHide: true });
-    if (child.pid !== undefined) {
+    const launched = startCommand(command, args, journalFd, errorsFd);
+    const child = 'error' in launched ? undefined : launched;
+    if (child?.pid !== undefined) {
         writeFileSync(`${journal}.pid`, `${child.pid}\n`);
         console.log(JSON.stringify({ pid: child.pid, journal, errors }));
     }
     // The signal aborts once the cap elapses, so whether it aborted is whether the cap ended the run.
     // The timer cannot be cleared, so a cap that elapses after the child exited kills nothing: a
     // reused pid is not this command's.
-    const deadline = capMilliseconds === undefined ? undefined : AbortSignal.timeout(capMilliseconds);
+    const deadline = child === undefined || capMilliseconds === undefined
+        ? undefined
+        : AbortSignal.timeout(capMilliseconds);
     deadline?.addEventListener('abort', () => {
-        if (child.pid !== undefined && child.exitCode === null && child.signalCode === null) {
+        if (child?.pid !== undefined && child.exitCode === null && child.signalCode === null) {
             killTree(child.pid);
         }
     }, { once: true });
-    const exit = await waitForExit(child);
+    const exit = 'error' in launched ? launched : await waitForExit(launched);
     const capped = deadline?.aborted === true;
     closeSync(journalFd);
     closeSync(errorsFd);
@@ -102,7 +117,7 @@ async function main(argv) {
     if (status)
         writeFileSync(`${journal}.status-after.txt`, readStatus());
     console.log(JSON.stringify({
-        pid: child.pid,
+        pid: child?.pid,
         exit: exit.error === undefined ? exit.code : 127,
         signal: exit.signal,
         capped,

package/dist/agents/skills/orkestrel-harden/scripts/titles.js

@@ -0,0 +1,338 @@
+// Run from the checkout root:
+//   node .agents/skills/orkestrel-harden/scripts/titles.ts --base REV [--root DIR] [--json] [--out FILE]
+// Compare exact decoded describe/it/test title counts in tests/**/*.test.ts against REV. Report
+// deficits with their baseline files, or as moved when another tests/**/*.ts string literal holds
+// the title. Confirm moved registrations by reading their holder. Decode quote and backslash
+// escapes only. Balance each-table parentheses over code tokens, skipping lexical regions.
+// Print text by default or one JSON line with --json; --out writes .json or .txt independently.
+// Compare interpolated templates by full raw spelling. Refuse unclosed lexical tokens.
+// Track lexical brace context without a syntax tree. Function-expression and arrow bodies cannot
+// establish a following slash's grammar; refuse that detectable ambiguity instead of claiming a move.
+// Exit 0 with no missing titles, 3 with missing titles, 2 on git, filesystem or token refusal, 64 on usage.
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { listFiles, normalizeSlashes, readMissingFlags, readOption, } from "../../orkestrel-dispatch/scripts/helpers.js";
+const TITLE_PATTERN = /^\s*(?:it|test|describe)(?:\.\w+)*\(/gmu;
+const REGEX_PREFIX = /^(?:return|throw|case|delete|void|typeof|instanceof|in|of|yield|await|else|do)$/u;
+function decodeTitle(text, token) {
+    const raw = text.slice(token.start + 1, token.end - 1);
+    return token.category === 'template' && token.children.length > 0
+        ? raw
+        : raw.replace(/\\(['"`\\])/gu, '$1');
+}
+class TokenScanner {
+    #text;
+    #file;
+    #parentheses = [];
+    #braces = [];
+    #position = 0;
+    constructor(text, file) {
+        this.#text = text;
+        this.#file = file;
+    }
+    scan() {
+        return this.#readCode(false, 0);
+    }
+    #readCode(expression, depth) {
+        if (depth > 256)
+            throw new Error(`${this.#file}: token nesting exceeds 256`);
+        const tokens = [];
+        while (this.#position < this.#text.length) {
+            const start = this.#position;
+            const rest = this.#text.slice(start);
+            const character = this.#text[start];
+            const previous = tokens.findLast((token) => token.category !== 'line' &&
+                token.category !== 'block' &&
+                this.#text.slice(token.start, token.end).trim().length > 0);
+            const spelling = previous === undefined ? '' : this.#text.slice(previous.start, previous.end);
+            if (character === '}' && expression) {
+                this.#position += 1;
+                return tokens;
+            }
+            if (character === '{') {
+                const block = previous === undefined
+                    ? this.#braces.at(-1)?.category !== 'template'
+                    : previous.category === 'code' &&
+                        /^(?:\)|=>|;|\{|\}|else|try|finally|do)$/u.test(spelling);
+                this.#braces.push({
+                    category: block ? 'block' : 'expression',
+                    ambiguous: block && (spelling === '=>' || previous?.ambiguous === true),
+                });
+                this.#position += 1;
+                tokens.push({ category: 'code', start, end: this.#position, children: [] });
+                tokens.push(...this.#readCode(true, depth + 1));
+                const brace = this.#braces.pop();
+                tokens.push({
+                    category: 'code',
+                    start: this.#position - 1,
+                    end: this.#position,
+                    children: [],
+                    prefix: brace?.category === 'block',
+                    ambiguous: brace?.ambiguous === true,
+                });
+                continue;
+            }
+            if (character === '`') {
+                tokens.push(this.#readTemplate(depth + 1));
+                continue;
+            }
+            if (character === '/' &&
+                !rest.startsWith('//') &&
+                !rest.startsWith('/*') &&
+                previous?.ambiguous === true)
+                throw new Error(`${this.#file}:${start}: Ambiguous brace before slash`);
+            const regex = character === '/' &&
+                !rest.startsWith('//') &&
+                !rest.startsWith('/*') &&
+                (previous === undefined ||
+                    previous.prefix === true ||
+                    (previous.category === 'code' &&
+                        (REGEX_PREFIX.test(spelling) ||
+                            !/^(?:[\p{ID_Continue}$]+|[\])}]|\+\+|--)$/u.test(spelling))));
+            const category = rest.startsWith('//')
+                ? 'line'
+                : rest.startsWith('/*')
+                    ? 'block'
+                    : character === "'" || character === '"'
+                        ? 'string'
+                        : regex
+                            ? 'regex'
+                            : 'code';
+            const match = category === 'line'
+                ? /^\/\/[^\r\n]*/u.exec(rest)
+                : category === 'block'
+                    ? /^\/\*[\s\S]*?\*\//u.exec(rest)
+                    : category === 'string'
+                        ? (character === "'"
+                            ? /^'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n\u2028\u2029])*'/u
+                            : /^"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n\u2028\u2029])*"/u).exec(rest)
+                        : category === 'regex'
+                            ? /^\/(?:\\[^\r\n]|\[(?:\\[^\r\n]|[^\]\\\r\n])*\]|[^/\\[\r\n])*\/[a-z]*/iu.exec(rest)
+                            : /^(?:[\p{ID_Start}_$][\p{ID_Continue}$]*|\d[\w.]*|\s+|\+\+|--|=>|.)/u.exec(rest);
+            if (match === null)
+                throw new Error(`${this.#file}:${start}: Unclosed ${category} token`);
+            this.#position += match[0].length;
+            if (category === 'code' && character === '(') {
+                const words = tokens
+                    .filter((token) => token.category === 'code')
+                    .map((token) => this.#text.slice(token.start, token.end))
+                    .filter((word) => word.trim().length > 0);
+                const keyword = words.findLastIndex((word) => word === 'function');
+                const callable = keyword >= 0 &&
+                    words
+                        .slice(keyword + 1)
+                        .every((word) => word === '*' || /^[\p{ID_Start}_$][\p{ID_Continue}$]*$/u.test(word));
+                const before = words[words[keyword - 1] === 'async' ? keyword - 2 : keyword - 1];
+                this.#parentheses.push({
+                    prefix: /^(?:if|while|for|with|switch|catch)$/u.test(spelling),
+                    ambiguous: callable &&
+                        (before === undefined
+                            ? this.#braces.at(-1)?.category === 'template'
+                            : /^(?:[=(,:[?+\-*/%&|^!~<>]|=>|return|throw|yield|await|case|new|void|typeof|delete|instanceof|in|of)$/u.test(before)),
+                });
+            }
+            const parenthesis = category === 'code' && character === ')' ? this.#parentheses.pop() : undefined;
+            tokens.push({
+                category,
+                start,
+                end: this.#position,
+                children: [],
+                prefix: parenthesis?.prefix === true,
+                ambiguous: parenthesis?.ambiguous === true,
+            });
+        }
+        if (expression)
+            throw new Error(`${this.#file}:${this.#position}: Unclosed template expression or brace`);
+        return tokens;
+    }
+    #readTemplate(depth) {
+        const start = this.#position;
+        const children = [];
+        this.#position += 1;
+        while (this.#position < this.#text.length) {
+            if (this.#text[this.#position] === '\\') {
+                this.#position += 2;
+            }
+            else if (this.#text[this.#position] === '`') {
+                this.#position += 1;
+                return { category: 'template', start, end: this.#position, children };
+            }
+            else if (this.#text.startsWith('${', this.#position)) {
+                const opening = this.#position;
+                this.#position += 2;
+                this.#braces.push({ category: 'template', ambiguous: false });
+                const expression = this.#readCode(true, depth);
+                this.#braces.pop();
+                children.push({
+                    category: 'code',
+                    start: opening,
+                    end: this.#position,
+                    children: expression,
+                });
+            }
+            else {
+                this.#position += 1;
+            }
+        }
+        throw new Error(`${this.#file}:${start}: Unclosed template token`);
+    }
+}
+function readArguments(text, tokens, location, depth) {
+    if (depth > 256)
+        throw new Error(`${location}: each argument nesting exceeds 256`);
+    for (const token of tokens) {
+        if (token.category !== 'code')
+            continue;
+        const spelling = text.slice(token.start, token.end);
+        if (spelling === '(')
+            readArguments(text, tokens, location, depth + 1);
+        else if (spelling === ')')
+            return token.end;
+    }
+    throw new Error(`${location}: Unbalanced each arguments`);
+}
+function readRegistrations(text, tokens, file) {
+    const code = tokens
+        .map((token) => {
+        const raw = text.slice(token.start, token.end);
+        if (token.category === 'code')
+            return raw;
+        const blank = raw
+            .split('')
+            .map((character) => (/[\r\n]/u.test(character) ? character : ' '))
+            .join('');
+        return token.category === 'string' || token.category === 'template'
+            ? `\0${blank.slice(1)}`
+            : blank;
+    })
+        .join('');
+    const offset = tokens[0]?.start ?? 0;
+    const positions = new Map(tokens.map((token, index) => [token.start, index]));
+    const starts = new Set(Array.from(code.matchAll(TITLE_PATTERN)).flatMap((match) => {
+        const opening = offset + match.index + match[0].length - 1;
+        const direct = /^\s*\0/u.exec(code.slice(opening + 1 - offset));
+        if (!/\.each\(/u.test(match[0]) && direct !== null)
+            return [opening + direct[0].length];
+        const index = positions.get(opening);
+        if (index === undefined)
+            return [];
+        const line = text.slice(0, opening).split(/\r\n|\n/u).length;
+        const end = readArguments(text, tokens.slice(index + 1).values(), `${file}:${line}`, 0);
+        const title = /^\s*\(\s*\0/u.exec(code.slice(end - offset));
+        return title === null ? [] : [end + title[0].length - 1];
+    }));
+    return [
+        ...tokens.filter((token) => starts.has(token.start)),
+        ...tokens.flatMap((token) => readRegistrations(text, token.children, file)),
+    ];
+}
+function collectLiterals(tokens) {
+    return tokens.flatMap((token) => [
+        ...(token.category === 'string' || token.category === 'template' ? [token] : []),
+        ...collectLiterals(token.children),
+    ]);
+}
+function readGit(root, args) {
+    const result = spawnSync('git', ['-C', root, ...args], {
+        encoding: 'utf8',
+        windowsHide: true,
+        maxBuffer: 256 * 1024 * 1024,
+    });
+    if (result.error !== undefined || result.status !== 0) {
+        throw new Error(`git: ${result.error?.message ?? result.stderr.trim()}`);
+    }
+    return result.stdout;
+}
+function readReport(base, root) {
+    const baseline = readGit(root, ['ls-tree', '-r', '-z', '--name-only', base, '--', 'tests'])
+        .split('\0')
+        .filter((file) => file.endsWith('.test.ts'))
+        .flatMap((file) => {
+        const text = readGit(root, ['show', `${base}:${file}`]);
+        return readRegistrations(text, new TokenScanner(text, `${base}:${file}`).scan(), `${base}:${file}`).map((token) => ({
+            file,
+            title: decodeTitle(text, token),
+        }));
+    });
+    const directory = join(root, 'tests');
+    const files = (existsSync(directory) ? listFiles(directory) : [])
+        .filter(({ path }) => path.endsWith('.ts'))
+        .map(({ path }) => {
+        const file = normalizeSlashes(relative(root, path));
+        const text = readFileSync(path, 'utf8');
+        const tokens = new TokenScanner(text, file).scan();
+        return {
+            file,
+            text,
+            tokens,
+            registrations: file.endsWith('.test.ts') ? readRegistrations(text, tokens, file) : [],
+        };
+    })
+        .sort((left, right) => left.file.localeCompare(right.file));
+    const titles = files
+        .filter(({ file }) => file.endsWith('.test.ts'))
+        .flatMap(({ file, text, registrations }) => registrations.map((token) => ({ file, title: decodeTitle(text, token) })));
+    // A surviving registration supplies its title count, never evidence that a lost duplicate moved.
+    const holders = files.flatMap(({ file, text, tokens, registrations }) => collectLiterals(tokens)
+        .filter((token) => !registrations.includes(token))
+        .map((token) => ({ file, title: decodeTitle(text, token) })));
+    const deficits = [...Map.groupBy(baseline, ({ title }) => title)].flatMap(([title, entries]) => {
+        const survivors = titles.filter((candidate) => candidate.title === title);
+        const unmatched = [...Map.groupBy(entries, ({ file }) => file)].flatMap(([file, local]) => local.slice(survivors.filter((candidate) => candidate.file === file).length));
+        const surplus = [...Map.groupBy(survivors, ({ file }) => file)].flatMap(([file, local]) => local.slice(entries.filter((candidate) => candidate.file === file).length));
+        return [...Map.groupBy(unmatched.slice(surplus.length), ({ file }) => file)].map(([file, lost]) => ({
+            file,
+            title,
+            deficit: lost.length,
+        }));
+    });
+    const classified = deficits.map((entry) => ({
+        entry,
+        holder: holders.find(({ title }) => title === entry.title)?.file,
+    }));
+    return {
+        base,
+        root: normalizeSlashes(root),
+        count: baseline.length,
+        missing: classified.flatMap(({ entry, holder }) => (holder === undefined ? [entry] : [])),
+        moved: classified.flatMap(({ entry, holder }) => holder === undefined ? [] : [{ file: entry.file, title: entry.title, holder }]),
+    };
+}
+function renderReport(report) {
+    return [
+        `titles: ${report.count} baseline title(s) at ${report.base}, ${report.missing.length} missing, ${report.moved.length} moved`,
+        ...report.missing.map(({ file, title, deficit }) => `missing\t${file}\t${title}\t${deficit}`),
+        ...report.moved.map(({ file, title, holder }) => `moved\t${file}\t${title}\t${holder}`),
+    ].join('\n');
+}
+function main(argv) {
+    const missing = readMissingFlags(argv, ['--base', '--root', '--out']);
+    if (missing.length > 0) {
+        console.error(`titles: ${missing.join(', ')} given with no value`);
+        return 64;
+    }
+    const base = readOption(argv, '--base');
+    const out = readOption(argv, '--out');
+    if (base === undefined || (out !== undefined && !['.json', '.txt'].includes(extname(out)))) {
+        console.error('usage: titles.ts --base REV [--root DIR] [--json] [--out FILE.json|FILE.txt]');
+        return 64;
+    }
+    try {
+        const report = readReport(base, resolve(readOption(argv, '--root') ?? process.cwd()));
+        const json = JSON.stringify(report);
+        const text = renderReport(report);
+        if (out !== undefined) {
+            const target = resolve(out);
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, `${extname(target) === '.json' ? json : text}\n`);
+        }
+        console.log(argv.includes('--json') ? json : text);
+        return report.missing.length > 0 ? 3 : 0;
+    }
+    catch (error) {
+        console.error(`titles: ${error instanceof Error ? error.message : String(error)}`);
+        return 2;
+    }
+}
+process.exitCode = main(process.argv.slice(2));

package/dist/agents/skills/orkestrel-publish/scripts/swap.js

@@ -36,9 +36,9 @@
 // Exit 0 on success, 1 when a command or a proof failed, 3 when --status reports drift, 64 on usage.
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, writeFileSync, } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { normalizeSlashes, parseJsonRecord, readMissingFlags, readOption, readOptions, readString, runNpm, } from "../../orkestrel-dispatch/scripts/helpers.js";
+import { isRecord, normalizeSlashes, parseJsonRecord, readMissingFlags, readOption, readOptions, readString, removeTree, runNpm, scanLocalSpecs, } from "../../orkestrel-dispatch/scripts/helpers.js";
 const FIELDS = ['dependencies', 'devDependencies'];
 const MODES = ['pin', 'restore', 'status'];
 const TARBALL_DIRECTORY = 'tmp/tarballs';
@@ -123,21 +123,6 @@ const OVERRIDE_PRECEDERS = [
     'bundleDependencies',
     'resolutions',
 ];
-// The manifest blocks whose values are dependency specs; `overrides` nests records of them.
-const SPEC_BLOCKS = [
-    'dependencies',
-    'devDependencies',
-    'peerDependencies',
-    'optionalDependencies',
-    'overrides',
-];
-// npm-package-arg reads a spec as local when it carries a `file:` or `link:` prefix or begins like a
-// path: a dot, `~/`, a separator, or a drive letter.
-const LOCAL_SPEC_PATTERN = /^(?:file:|link:|\.|~[\\/]|[\\/]|[A-Za-z]:)/iu;
-// It also reads a spec as local when the spec ends in an archive extension and carries no protocol...
-const ARCHIVE_SPEC_PATTERN = /^[^:]+\.(?:tgz|tar\.gz|tar)$/iu;
-// ...unless the spec is a `user/repo` shorthand, which names a hosted repository whatever it ends in.
-const SHORTHAND_SPEC_PATTERN = /^[^:@%/\s.-][^:@%/\s]*\/[^:@\s/%]+$/u;
 // An optional `@scope/` and a name of the characters a registry URL carries untouched; a path
 // separator beyond the scope's one `/`, an absolute form, and a drive form fall outside it.
 const PACKAGE_NAME_PATTERN = /^(?:@[A-Za-z0-9~-][A-Za-z0-9._~-]*\/)?[A-Za-z0-9~-][A-Za-z0-9._~-]*$/u;
@@ -147,14 +132,6 @@ const USAGE = [
     '       swap.ts --restore --consumer DIR [--package NAME ...] [--json]',
     '       swap.ts --status --consumer DIR [--json]',
 ].join('\n');
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isLocalSpec(spec) {
-    const text = spec.trimStart();
-    return (LOCAL_SPEC_PATTERN.test(text) ||
-        (ARCHIVE_SPEC_PATTERN.test(text) && !SHORTHAND_SPEC_PATTERN.test(text)));
-}
 function isPackageName(name) {
     return (name.length <= PACKAGE_NAME_LIMIT && !name.includes('..') && PACKAGE_NAME_PATTERN.test(name));
 }
@@ -632,9 +609,6 @@ function replaceFile(path, text) {
     writeFileSync(temporary, text);
     renameSync(temporary, path);
 }
-function removeTree(path) {
-    rmSync(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
-}
 // Vite keys its pre-bundle on the installed version, so a same-version tarball would serve stale bytes.
 function installConsumer(consumer) {
     invokeNpm(['install', '--ignore-scripts', '--no-audit', '--no-fund'], consumer);
@@ -842,17 +816,7 @@ function readPackedManifest(directory) {
 // or not a ledger recorded the spec.
 function scanPackedSpecs(source) {
     const manifest = loadPackedManifest(source.directory);
-    return SPEC_BLOCKS.flatMap((block) => collectSpecs(block, manifest[block]).flatMap(([path, spec]) => isLocalSpec(spec)
-        ? [`${source.name} would pack a local dependency spec: ${path} is ${spec}`]
-        : []));
-}
-// An `overrides` value can nest records, so the path names every key down to the spec.
-function collectSpecs(path, value) {
-    if (typeof value === 'string')
-        return [[path, value]];
-    if (!isRecord(value))
-        return [];
-    return Object.entries(value).flatMap(([key, child]) => collectSpecs(`${path}.${key}`, child));
+    return scanLocalSpecs(manifest).map(([path, spec]) => `${source.name} would pack a local dependency spec: ${path} is ${spec}`);
 }
 // A source that carries a ledger of its own has its manifest rewritten to the recorded ranges for the
 // pack and restored byte for byte whether the pack succeeds or throws, so a consumer never receives a