@hominis/fireforge 0.50.0 → 0.51.0

package/dist/src/core/park-store.js

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Storage and merge logic behind `fireforge park`.
+ *
+ * Several sessions edit the same Hominis files on one engine, and a peer's
+ * `re-export --refuse-foreign-drift` refuses while another session's hunks
+ * sit in its patch's files. Setting those hunks aside meant reversing each
+ * one by hand. A park records, for every file of one patch that drifted:
+ *
+ *  - `before`: the file as the session left it (what the park takes away),
+ *  - `after`: what the park writes in its place (the queue-applied
+ *    baseline, or the working tree minus the named hunks).
+ *
+ * Restoring is a three-way merge of the file as it is now (ours) with
+ * `before` (theirs) over `after` (base), so the owner's commit in between
+ * is kept and the parked hunks come back on top of it.
+ *
+ * A park lives under `.fireforge/park/<label>/`: `park.json` plus one copy
+ * of each side per file. Absent files are recorded as absent, never as
+ * empty.
+ */
+import { mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { InvalidArgumentError } from '../errors/base.js';
+import { getNodeErrorCode } from '../utils/errors.js';
+import { ensureDir, pathExists, readJson, readText, removeFile, writeJson, writeText, } from '../utils/fs.js';
+import { exec } from '../utils/process.js';
+import { FIREFORGE_DIR } from './config-paths.js';
+const LABEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/** The directory holding every park of a project. */
+function parkRoot(projectRoot) {
+    return join(projectRoot, FIREFORGE_DIR, 'park');
+}
+/** Refuses a label that is not a plain file-name segment. */
+function assertParkLabel(label) {
+    if (!LABEL_PATTERN.test(label)) {
+        throw new InvalidArgumentError(`Park label "${label}" must be letters, digits, ".", "_" or "-", starting with a letter or digit.`, '--label');
+    }
+}
+function sideDir(dir, side) {
+    return join(dir, side);
+}
+/** Writes a park; refuses to overwrite an existing label. */
+export async function writePark(projectRoot, record) {
+    assertParkLabel(record.label);
+    const dir = join(parkRoot(projectRoot), record.label);
+    if (await pathExists(dir)) {
+        throw new InvalidArgumentError(`A park named "${record.label}" already exists. Restore or drop it first, or pass another --label.`, '--label');
+    }
+    for (const file of record.files) {
+        for (const side of ['before', 'after']) {
+            const content = file[side];
+            if (content === null)
+                continue;
+            const target = join(sideDir(dir, side), file.path);
+            await ensureDir(dirname(target));
+            await writeText(target, content);
+        }
+    }
+    const index = {
+        label: record.label,
+        patch: record.patch,
+        createdAt: record.createdAt,
+        mode: record.mode,
+        files: record.files.map((file) => ({
+            path: file.path,
+            before: file.before !== null,
+            after: file.after !== null,
+        })),
+    };
+    await writeJson(join(dir, 'park.json'), index);
+    return dir;
+}
+/** Reads a park back, contents included. */
+export async function readPark(projectRoot, label) {
+    assertParkLabel(label);
+    const dir = join(parkRoot(projectRoot), label);
+    if (!(await pathExists(join(dir, 'park.json')))) {
+        throw new InvalidArgumentError(`No park named "${label}". List them with "fireforge park --list".`, label);
+    }
+    const index = await readJson(join(dir, 'park.json'));
+    const files = [];
+    for (const entry of index.files) {
+        files.push({
+            path: entry.path,
+            before: entry.before ? await readText(join(sideDir(dir, 'before'), entry.path)) : null,
+            after: entry.after ? await readText(join(sideDir(dir, 'after'), entry.path)) : null,
+        });
+    }
+    return { ...index, files };
+}
+/** Every park of the project, oldest first. */
+export async function listParks(projectRoot) {
+    let names;
+    try {
+        names = (await readdir(parkRoot(projectRoot), { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch (error) {
+        if (getNodeErrorCode(error) === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const parks = [];
+    for (const name of names) {
+        const path = join(parkRoot(projectRoot), name, 'park.json');
+        if (await pathExists(path))
+            parks.push(await readJson(path));
+    }
+    return parks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+/** Deletes a park. */
+export async function dropPark(projectRoot, label) {
+    assertParkLabel(label);
+    const dir = join(parkRoot(projectRoot), label);
+    if (!(await pathExists(dir))) {
+        throw new InvalidArgumentError(`No park named "${label}".`, label);
+    }
+    await rm(dir, { recursive: true, force: true });
+}
+/** Reads an engine file, null when absent. */
+export async function readEngineFile(engineDir, path) {
+    const full = join(engineDir, path);
+    return (await pathExists(full)) ? await readText(full) : null;
+}
+/** Writes an engine file, removing it for null. */
+export async function writeEngineFile(engineDir, path, content) {
+    const full = join(engineDir, path);
+    if (content === null) {
+        if (await pathExists(full))
+            await removeFile(full);
+        return;
+    }
+    await ensureDir(dirname(full));
+    await writeText(full, content);
+}
+/**
+ * Three-way merges `ours` and `theirs` over `base` with `git merge-file`.
+ * Conflicts come back as marker blocks.
+ */
+export async function mergeThreeWay(ours, base, theirs, path) {
+    const scratch = await mkdtemp(join(tmpdir(), 'fireforge-park-'));
+    try {
+        const files = {
+            ours: join(scratch, 'ours'),
+            base: join(scratch, 'base'),
+            theirs: join(scratch, 'theirs'),
+        };
+        await writeFile(files.ours, ours);
+        await writeFile(files.base, base);
+        await writeFile(files.theirs, theirs);
+        const result = await exec('git', [
+            'merge-file',
+            '-p',
+            '-L',
+            `${path} (now)`,
+            '-L',
+            `${path} (parked from)`,
+            '-L',
+            `${path} (parked)`,
+            files.ours,
+            files.base,
+            files.theirs,
+        ]);
+        if (result.exitCode < 0 || result.exitCode > 127) {
+            throw new Error(`git merge-file failed for ${path}: ${result.stderr.trim()}`);
+        }
+        return { content: result.stdout, conflicts: result.exitCode };
+    }
+    finally {
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+/**
+ * What restoring one parked file writes: `before` when the file is still
+ * as the park left it, nothing when it already matches `before`, and a
+ * three-way merge otherwise. Absence only merges with absence.
+ */
+export async function planRestore(file, now) {
+    if (now === file.after)
+        return { outcome: 'restored', content: file.before };
+    if (now === file.before)
+        return { outcome: 'unchanged', content: now };
+    if (now === null || file.before === null || file.after === null) {
+        return { outcome: 'conflict', content: now };
+    }
+    const merged = await mergeThreeWay(now, file.after, file.before, file.path);
+    return { outcome: merged.conflicts > 0 ? 'conflict' : 'merged', content: merged.content };
+}
+/** Message ids a Fluent file's lines declare (`id = …`, `-term = …`). */
+export function fluentIds(lines) {
+    const ids = [];
+    for (const line of lines) {
+        const match = /^(-?[A-Za-z][\w-]*)\s*=/.exec(line);
+        if (match?.[1] !== undefined)
+            ids.push(match[1]);
+    }
+    return ids;
+}
+/** Lines `before` has that `after` lacks, as a multiset difference. */
+export function removedLines(before, after) {
+    const remaining = new Map();
+    for (const line of (after ?? '').split('\n'))
+        remaining.set(line, (remaining.get(line) ?? 0) + 1);
+    const removed = [];
+    for (const line of (before ?? '').split('\n')) {
+        const count = remaining.get(line) ?? 0;
+        if (count > 0)
+            remaining.set(line, count - 1);
+        else
+            removed.push(line);
+    }
+    return removed;
+}

package/dist/src/core/patch-export-update.d.ts

@@ -24,6 +24,8 @@ export interface UpdatePatchAndMetadataOptions {
     newContent: string;
     /** Manifest-row fields to merge into the patch's metadata. */
     updates: Partial<PatchMetadata>;
+    /** Manifest-row fields to delete, e.g. a staged block left empty. */
+    unset?: readonly (keyof PatchMetadata)[] | undefined;
     /** Hook run under the lock after the mutation succeeds. */
     onCommitted?: UpdatePatchCommittedHook | undefined;
     /** Policy gate run against the under-lock projected manifest. */
@@ -49,3 +51,5 @@ export interface UpdatePatchAndMetadataOptions {
  *   already byte-identical to the new content.
  */
 export declare function updatePatchAndMetadata(options: UpdatePatchAndMetadataOptions): Promise<boolean>;
+/** A copy of `row` without `fields`. */
+export declare function withoutFields(row: PatchMetadata, fields: readonly (keyof PatchMetadata)[]): PatchMetadata;

package/dist/src/core/patch-export-update.js

@@ -25,7 +25,7 @@ import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
  *   already byte-identical to the new content.
  */
 export async function updatePatchAndMetadata(options) {
-    const { patchesDir, filename, newContent, updates, onCommitted, policyGate, lockOptions = {}, } = options;
+    const { patchesDir, filename, newContent, updates, unset = [], onCommitted, policyGate, lockOptions = {}, } = options;
     return withPatchDirectoryLock(patchesDir, async () => {
         const manifest = await loadPatchesManifestForWrite(patchesDir);
         if (!manifest) {
@@ -41,7 +41,7 @@ export async function updatePatchAndMetadata(options) {
         }
         const originalContent = await readText(patchPath);
         const existingPatch = manifest.patches[patchIndex];
-        manifest.patches[patchIndex] = { ...existingPatch, ...updates };
+        manifest.patches[patchIndex] = withoutFields({ ...existingPatch, ...updates }, unset);
         if (policyGate !== undefined) {
             enforcePatchPolicy({
                 config: policyGate.config,
@@ -59,7 +59,7 @@ export async function updatePatchAndMetadata(options) {
                 await writeText(patchPath, normalized);
                 patchWritten = true;
             }
-            await mutatePatchRowsInManifest(patchesDir, [filename], () => ({ set: updates }));
+            await mutatePatchRowsInManifest(patchesDir, [filename], () => ({ set: updates, unset }));
         }
         catch (error) {
             if (patchWritten) {
@@ -84,3 +84,12 @@ export async function updatePatchAndMetadata(options) {
         return bodyChanged;
     }, lockOptions);
 }
+/** A copy of `row` without `fields`. */
+export function withoutFields(row, fields) {
+    if (fields.length === 0)
+        return row;
+    const copy = { ...row };
+    for (const field of fields)
+        Reflect.deleteProperty(copy, field);
+    return copy;
+}

package/dist/src/core/patch-export.d.ts

@@ -18,9 +18,10 @@ export declare function buildPlanExportInput(input: PlanExportInput): PlanExport
 /**
  * Gets the next patch number for a new patch.
  * @param patchesDir - Path to the patches directory
+ * @param reserved - Orders held by `patch reserve`, skipped
  * @returns Next patch number (e.g., "005" for 4 existing patches)
  */
-export declare function getNextPatchNumber(patchesDir: string): Promise<string>;
+export declare function getNextPatchNumber(patchesDir: string, reserved?: ReadonlySet<number>): Promise<string>;
 /**
  * Sanitizes a human-readable name into a filename slug.
  *
@@ -59,7 +60,7 @@ export declare function patchNameSlug(name: string, category: string): string;
  * @param name - Human-readable name
  * @returns Filename like "001-ui-sidebar.patch"
  */
-export declare function getNextPatchFilename(patchesDir: string, category: PatchCategory, name: string): Promise<string>;
+export declare function getNextPatchFilename(patchesDir: string, category: PatchCategory, name: string, reserved?: ReadonlySet<number>): Promise<string>;
 export interface CommitExportedPatchInput {
     patchesDir: string;
     category: PatchCategory;

package/dist/src/core/patch-export.js

@@ -2,13 +2,13 @@
 import { join } from 'node:path';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
+import { info, warn } from '../utils/logger.js';
 import { discoverPatches, withPatchDirectoryLock } from './patch-apply.js';
 import { findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { addPatchToManifest, loadPatchesManifestForWrite, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
 import { formatPatchOrder, requirePatchOrder } from './patch-parse.js';
 import { allocatePolicyOrder, enforcePatchPolicy } from './patch-policy.js';
-import { manifestWithRetiredSlots } from './patch-retired.js';
+import { manifestWithRetiredSlots, reservationAt, reservedOrderSet } from './patch-retired.js';
 export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { escapeRegex } from '../utils/regex.js';
 export { mutatePatchMetadata, updatePatchMetadata } from './patch-export-metadata.js';
@@ -40,18 +40,16 @@ export function buildPlanExportInput(input) {
 /**
  * Gets the next patch number for a new patch.
  * @param patchesDir - Path to the patches directory
+ * @param reserved - Orders held by `patch reserve`, skipped
  * @returns Next patch number (e.g., "005" for 4 existing patches)
  */
-export async function getNextPatchNumber(patchesDir) {
+export async function getNextPatchNumber(patchesDir, reserved = new Set()) {
     const patches = await discoverPatches(patchesDir);
-    if (patches.length === 0) {
-        return '001';
-    }
     const finitePatches = patches.filter((p) => Number.isFinite(p.order));
-    if (finitePatches.length === 0)
-        return '001';
     const maxOrder = finitePatches.reduce((max, p) => Math.max(max, p.order), 0);
-    const nextNumber = maxOrder + 1;
+    let nextNumber = maxOrder + 1;
+    while (reserved.has(nextNumber))
+        nextNumber++;
     return String(nextNumber).padStart(Math.max(3, String(nextNumber).length), '0');
 }
 /**
@@ -118,8 +116,8 @@ export function patchNameSlug(name, category) {
  * @param name - Human-readable name
  * @returns Filename like "001-ui-sidebar.patch"
  */
-export async function getNextPatchFilename(patchesDir, category, name) {
-    const patchNumber = await getNextPatchNumber(patchesDir);
+export async function getNextPatchFilename(patchesDir, category, name, reserved = new Set()) {
+    const patchNumber = await getNextPatchNumber(patchesDir, reserved);
     const sanitizedName = patchNameSlug(name, category);
     return `${patchNumber}-${category}-${sanitizedName}.patch`;
 }
@@ -234,12 +232,15 @@ async function computeExportPlanUnderLock(input) {
     // wipes the queue metadata, and the rollback path would then delete
     // patches.json entirely because manifestBefore looked absent.
     const manifestBefore = await loadPatchesManifestForWrite(input.patchesDir);
+    // A default allocation never lands on a reservation; only an explicit
+    // `--order` placement fills one.
+    const reserved = reservedOrderSet(manifestBefore ?? {});
     const policyOrder = input.config !== undefined
-        ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category)
+        ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category, reserved)
         : null;
     const patchFilename = policyOrder !== null
         ? `${formatPatchOrder(policyOrder)}-${input.category}-${patchNameSlug(input.name, input.category)}.patch`
-        : await getNextPatchFilename(input.patchesDir, input.category, input.name);
+        : await getNextPatchFilename(input.patchesDir, input.category, input.name, reserved);
     const patchPath = join(input.patchesDir, patchFilename);
     const metadata = {
         filename: patchFilename,
@@ -267,6 +268,12 @@ async function computeExportPlanUnderLock(input) {
     const afterPatches = (manifestBefore?.patches ?? []).filter((p) => !supersededSet.has(p.filename) && p.filename !== patchFilename);
     afterPatches.push(metadata);
     afterPatches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
+    const reservation = reservationAt(manifestBefore, metadata.order);
+    if (reservation !== undefined) {
+        info(`Order ${formatPatchOrder(metadata.order)} was reserved by ${reservation.owner}` +
+            `${reservation.reason !== undefined ? ` (${reservation.reason})` : ''}; ` +
+            'this export fills the reservation.');
+    }
     return {
         patchFilename,
         patchPath,
@@ -274,7 +281,7 @@ async function computeExportPlanUnderLock(input) {
         supersededDetails,
         supersededPatches,
         manifestBefore: manifestBefore ?? null,
-        // A patch landing on a retired order fills that slot.
+        // A patch landing on a retired or reserved order fills that slot.
         manifestAfter: manifestWithRetiredSlots(manifestBefore, afterPatches),
     };
 }

package/dist/src/core/patch-files.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { readdir } from 'node:fs/promises';
+import { readdir, stat } from 'node:fs/promises';
 import { extname, join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
 import { extractAffectedFiles, extractOrder } from './patch-parse.js';
@@ -9,16 +9,34 @@ export async function discoverPatches(patchesDir) {
         return [];
     }
     const entries = await readdir(patchesDir, { withFileTypes: true });
-    const patches = entries
-        .filter((entry) => entry.isFile() && extname(entry.name) === '.patch')
-        .map((entry) => ({
-        path: join(patchesDir, entry.name),
-        filename: entry.name,
-        order: extractOrder(entry.name),
-    }));
+    const patches = [];
+    for (const entry of entries) {
+        if (extname(entry.name) !== '.patch')
+            continue;
+        // A symlinked patch (a scratch queue built from links to the real
+        // patches) counts when it resolves to a regular file; a dangling link or
+        // a link to a directory does not.
+        if (!entry.isFile() &&
+            !(entry.isSymbolicLink() && (await isLinkToFile(patchesDir, entry.name)))) {
+            continue;
+        }
+        patches.push({
+            path: join(patchesDir, entry.name),
+            filename: entry.name,
+            order: extractOrder(entry.name),
+        });
+    }
     patches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
     return patches;
 }
+async function isLinkToFile(dir, name) {
+    try {
+        return (await stat(join(dir, name))).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 /** Counts the patch files currently present in a patch directory. */
 export async function countPatches(patchesDir) {
     const patches = await discoverPatches(patchesDir);

package/dist/src/core/patch-lint-checkjs-any-import.d.ts

@@ -2,10 +2,12 @@
  * Explains an implicit-`any` checkJs finding that comes from a URL import
  * the per-patch program cannot resolve.
  *
- * The program only holds patch-owned files (and, for a test, its own
- * directory's head.js), so a `resource:///` or `chrome://` import of a
- * module another patch creates falls back to the shim's
- * `declare module 'resource:*'` wildcard and types as `any`. A callback
+ * The program resolves URL imports only to modules the queue creates (for
+ * a test, those created up to its own patch, plus its directory's
+ * head.js), so a `resource:///` or `chrome://` import of a module a later
+ * patch creates, an upstream module, or a basename two patches create
+ * falls back to the shim's `declare module 'resource:*'` wildcard and
+ * types as `any`. A callback
  * over its values then has implicitly-`any` parameters under
  * `checkJsStrict`, while the whole-tree `fireforge typecheck`, which sees
  * the module, is clean. Without the note the two disagree with no

package/dist/src/core/patch-lint-checkjs-any-import.js

@@ -3,10 +3,12 @@
  * Explains an implicit-`any` checkJs finding that comes from a URL import
  * the per-patch program cannot resolve.
  *
- * The program only holds patch-owned files (and, for a test, its own
- * directory's head.js), so a `resource:///` or `chrome://` import of a
- * module another patch creates falls back to the shim's
- * `declare module 'resource:*'` wildcard and types as `any`. A callback
+ * The program resolves URL imports only to modules the queue creates (for
+ * a test, those created up to its own patch, plus its directory's
+ * head.js), so a `resource:///` or `chrome://` import of a module a later
+ * patch creates, an upstream module, or a basename two patches create
+ * falls back to the shim's `declare module 'resource:*'` wildcard and
+ * types as `any`. A callback
  * over its values then has implicitly-`any` parameters under
  * `checkJsStrict`, while the whole-tree `fireforge typecheck`, which sees
  * the module, is clean. Without the note the two disagree with no
@@ -35,9 +37,9 @@ export function anyTypedImportHint(code, specifiers) {
         return '';
     const list = [...specifiers].sort().join(', ');
     return (` (This file imports ${list}, which this per-patch checkJs program cannot resolve — ` +
-        'the module is created by another patch outside this program, a later one or one this ' +
-        'test does not share a directory with — so the import is typed `any`. Annotate the ' +
-        'parameter explicitly; the whole-tree "fireforge typecheck" resolves the real type.)');
+        'no patch up to this one creates the module under that name: a later patch creates it, ' +
+        'it is upstream, or two patches create the same basename — so the import is typed `any`. ' +
+        'Annotate the parameter explicitly; the whole-tree "fireforge typecheck" resolves the real type.)');
 }
 /**
  * The host's `resolveModuleNameLiterals`: owned specifiers first, then a

package/dist/src/core/patch-lint-checkjs-diagnostics.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Collects a checkJs program's diagnostics, for every file or for a report
+ * scope only. A per-test program resolves the modules its imports reach
+ * (see `runCheckJsTestFilesGrouped`), and asking for the whole program's
+ * diagnostics would type-check each of those modules once per test, so a
+ * scoped run asks only for the files it reports. Split out of
+ * patch-lint-checkjs.ts for the line budget.
+ */
+/**
+ * The program's semantic and syntactic diagnostics, limited to the files
+ * `reportOnly` names when it is set.
+ *
+ * @param program - The built program
+ * @param relByAbsolute - Owned files: TS path → repo-relative path
+ * @param reportOnly - Repo-relative files to collect for, or all when unset
+ */
+export declare function collectCheckJsDiagnostics(program: import('typescript').Program, relByAbsolute: ReadonlyMap<string, string>, reportOnly: ReadonlySet<string> | undefined): import('typescript').Diagnostic[];

package/dist/src/core/patch-lint-checkjs-diagnostics.js

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Collects a checkJs program's diagnostics, for every file or for a report
+ * scope only. A per-test program resolves the modules its imports reach
+ * (see `runCheckJsTestFilesGrouped`), and asking for the whole program's
+ * diagnostics would type-check each of those modules once per test, so a
+ * scoped run asks only for the files it reports. Split out of
+ * patch-lint-checkjs.ts for the line budget.
+ */
+/**
+ * The program's semantic and syntactic diagnostics, limited to the files
+ * `reportOnly` names when it is set.
+ *
+ * @param program - The built program
+ * @param relByAbsolute - Owned files: TS path → repo-relative path
+ * @param reportOnly - Repo-relative files to collect for, or all when unset
+ */
+export function collectCheckJsDiagnostics(program, relByAbsolute, reportOnly) {
+    if (reportOnly === undefined) {
+        return [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()];
+    }
+    return program
+        .getSourceFiles()
+        .filter((sourceFile) => {
+        const rel = relByAbsolute.get(sourceFile.fileName);
+        return rel !== undefined && reportOnly.has(rel);
+    })
+        .flatMap((sourceFile) => [
+        ...program.getSemanticDiagnostics(sourceFile),
+        ...program.getSyntacticDiagnostics(sourceFile),
+    ]);
+}

package/dist/src/core/patch-lint-checkjs.d.ts

@@ -82,6 +82,8 @@ export interface RunCheckJsGroupedInput {
      * compiler options and shim in one run. See {@link runCheckJsTestFilesGrouped}.
      */
     sourceFileCache?: CheckJsSourceFileCache;
+    /** When set, diagnostics are collected only for these repo-relative files. */
+    reportOnly?: ReadonlySet<string>;
 }
 /**
  * Builds the checkJs program once over `resolutionOwned` and returns its
@@ -136,12 +138,19 @@ export declare function invokePatchLintCheckJs(repoDir: string, patchOwnedFiles:
  * reported per program (head helpers report from their own program), and
  * run-level errors are de-duplicated across programs.
  *
+ * With `resolvableModules`, a test's `resource:///` and `chrome://`
+ * imports also resolve to the modules it returns for that test (the
+ * modules the queue creates up to the test's own patch), so a test that
+ * imports an earlier patch's module is typed against its real source
+ * instead of the shim's `any` wildcard. Those modules are resolution
+ * targets only: never roots, and never reported on.
+ *
  * @param repoDir - Absolute engine (repository) directory
  * @param testFiles - Patch-owned test-script paths (repo-relative)
  * @param patchLint - The resolved `patchLint` config block
  * @param projectRoot - FireForge project root for shim resolution
  */
-export declare function runCheckJsTestFilesGrouped(repoDir: string, testFiles: Set<string>, patchLint: PatchLintConfig, projectRoot: string, rootScope?: ReadonlySet<string>): Promise<GroupedCheckJsResult>;
+export declare function runCheckJsTestFilesGrouped(repoDir: string, testFiles: Set<string>, patchLint: PatchLintConfig, projectRoot: string, rootScope?: ReadonlySet<string>, resolvableModules?: (testFile: string) => ReadonlySet<string>): Promise<GroupedCheckJsResult>;
 /**
  * Grouped variant of {@link invokePatchLintCheckJs}: builds one queue-wide
  * checkJs program over `patchOwnedFiles` and returns its findings grouped by

package/dist/src/core/patch-lint-checkjs.js

@@ -33,6 +33,7 @@ import { normalizePathSlashes } from '../utils/paths.js';
 import { withGeckoDomTypes } from './gecko-dom-types.js';
 import { anyTypedImportHint, createModuleLiteralResolver, } from './patch-lint-checkjs-any-import.js';
 import { withSharedSourceFiles } from './patch-lint-checkjs-cache.js';
+import { collectCheckJsDiagnostics } from './patch-lint-checkjs-diagnostics.js';
 import { collectUnmanagedCompanions, retargetUnmanagedCompanionHints, } from './patch-lint-unmanaged-companion.js';
 import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES, TEST_HARNESS_SHIM, UNDEFINED_IDENTIFIER_CODES, UNDEFINED_IDENTIFIER_HINT, } from './typecheck-shim.js';
 // ---------------------------------------------------------------------------
@@ -340,7 +341,7 @@ export async function runCheckJsGrouped(input) {
         resolveModuleNameLiterals: createModuleLiteralResolver(resolveOwnedSpecifier, resolveViaPaths, anyTypedImports),
     };
     const program = ts.createProgram(rootFiles, options, withSharedSourceFiles(host, input.sourceFileCache, shimPath, shimSource));
-    const byFile = groupOwnedDiagnostics(ts, [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()], relByAbsolute, input.mode?.undefinedIdentifiers ?? 'warning', anyTypedImports);
+    const byFile = groupOwnedDiagnostics(ts, collectCheckJsDiagnostics(program, relByAbsolute, input.reportOnly), relByAbsolute, input.mode?.undefinedIdentifiers ?? 'warning', anyTypedImports);
     verbose(`checkJs: analyzed ${rootFiles.length - 1} file(s) across ${byFile.size} owning file(s)`);
     return { byFile, global: [] };
 }
@@ -448,12 +449,19 @@ export async function invokePatchLintCheckJs(repoDir, patchOwnedFiles, patchLint
  * reported per program (head helpers report from their own program), and
  * run-level errors are de-duplicated across programs.
  *
+ * With `resolvableModules`, a test's `resource:///` and `chrome://`
+ * imports also resolve to the modules it returns for that test (the
+ * modules the queue creates up to the test's own patch), so a test that
+ * imports an earlier patch's module is typed against its real source
+ * instead of the shim's `any` wildcard. Those modules are resolution
+ * targets only: never roots, and never reported on.
+ *
  * @param repoDir - Absolute engine (repository) directory
  * @param testFiles - Patch-owned test-script paths (repo-relative)
  * @param patchLint - The resolved `patchLint` config block
  * @param projectRoot - FireForge project root for shim resolution
  */
-export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint, projectRoot, rootScope) {
+export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint, projectRoot, rootScope, resolvableModules) {
     const merged = { byFile: new Map(), global: [] };
     if (testFiles.size === 0)
         return merged;
@@ -484,7 +492,9 @@ export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint,
         }
         const result = await runCheckJsGrouped({
             repoDir,
-            resolutionOwned: roots,
+            resolutionOwned: new Set([...roots, ...(resolvableModules?.(file) ?? [])]),
+            rootScope: roots,
+            reportOnly: new Set([file]),
             ...(patchLint.checkJsTestShim !== undefined
                 ? { extraShimPath: patchLint.checkJsTestShim }
                 : {}),

package/dist/src/core/patch-lint-cross.d.ts

@@ -10,7 +10,7 @@
  * module.
  */
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig, PatchPolicyConfig } from '../types/config.js';
+import type { FireForgeConfig, PatchLintTokenScale, PatchPolicyConfig } from '../types/config.js';
 import type { ForwardRegistrationScope } from './patch-lint-forward-registration-extended.js';
 /**
  * One patch's contribution to {@link PatchQueueContext}.
@@ -82,6 +82,8 @@ export interface PatchQueueContext {
      * `patchLint.forwardRegistration`. Absent = `support-files` only.
      */
     forwardRegistration?: ForwardRegistrationScope;
+    /** `patchLint.tokenScales`, for the scales' `minFiles` floors. */
+    tokenScales?: PatchLintTokenScale[];
 }
 /**
  * Builds a {@link PatchQueueContext} by reading every .patch file in the

package/dist/src/core/patch-lint-cross.js

@@ -21,6 +21,7 @@ import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-dif
 import { lintPatchQueueForwardRegistrations } from './patch-lint-forward-registration.js';
 import { lintPatchQueueModuleRegistrations } from './patch-lint-module-registration.js';
 import { describeRegistrationFailure, findStagedRegistrationFailure, isLaterOwner, quoteRegistrationLine, STAGED_DEPENDENCY_REASON_PLACEHOLDER, stagedDependencyUnusedFingerprint, } from './patch-lint-staged-registration.js';
+import { lintTokenScaleFloors } from './patch-lint-token-scale.js';
 import { loadPatchesManifest } from './patch-manifest-io.js';
 import { categoryRangeForOrder, categoryRangeLabel } from './patch-policy.js';
 import { extractNewFileContentsFromDiff } from './patch-transform.js';
@@ -88,6 +89,9 @@ export async function buildPatchQueueContext(patchesDir, config) {
         ...(config?.patchLint?.forwardRegistration !== undefined
             ? { forwardRegistration: config.patchLint.forwardRegistration }
             : {}),
+        ...(config?.patchLint?.tokenScales !== undefined
+            ? { tokenScales: config.patchLint.tokenScales }
+            : {}),
     };
 }
 // The creators map (split out of `lintPatchQueueDuplicateCreations` so
@@ -581,5 +585,6 @@ export function lintPatchQueue(ctx) {
         ...lintPatchQueueModuleRegistrations(ctx),
         ...lintPatchQueueForwardRegistrations(ctx),
         ...lintPatchQueueBinaryBodies(ctx),
+        ...lintTokenScaleFloors(ctx.entries.flatMap((entry) => [...entry.newFiles]), ctx.tokenScales ?? []),
     ];
 }