@hominis/fireforge 0.40.0 → 0.42.0

package/dist/src/commands/furnace/rename-browser-test.js

@@ -16,9 +16,58 @@ export function updateBrowserChromeTestContent(content, oldName, newName, binary
     const newUnderscored = newName.replace(/-/g, '_');
     const oldTestStem = deriveTestStem(oldName, binaryName);
     const newTestStem = deriveTestStem(newName, binaryName);
-    return content
-        .replace(new RegExp(escapeRegex(oldName), 'g'), newName)
-        .replace(new RegExp(escapeRegex(oldClassName), 'g'), newClassName)
-        .replace(new RegExp(escapeRegex(oldUnderscored), 'g'), newUnderscored)
-        .replace(new RegExp(escapeRegex(oldTestStem), 'g'), newTestStem);
+    // ONE pass over the content, not four chained `.replace()` calls.
+    //
+    // Chaining let each rule see the previous rule's output. Renaming
+    // `acme-widget` to `acme-widget-v2` rewrote `test_acme_widget_defined` to
+    // `test_acme_widget_v2_defined` via the underscored form, and then the stem
+    // rule matched the `acme_widget` still inside that result and produced
+    // `test_acme_widget_v2_v2_defined`. A single alternation with a callback
+    // cannot re-enter its own output.
+    //
+    // Ordering is longest-first, because JS alternation takes the first
+    // alternative that matches at a given position.
+    const alternatives = [
+        // The stem is a short bare fragment (`moz-` and binary prefixes stripped,
+        // hyphens underscored) — `panel` for `moz-panel`. Matching it loose, even
+        // with hyphen guards, rewrote unrelated underscore-delimited identifiers
+        // such as `test_panel_group_integration`, because `_` must stay a legal
+        // neighbour for the generated name to match at all. The scaffold emits the
+        // stem in exactly one shape, so anchor to that shape instead of guessing
+        // from boundaries — with its own guards, so the anchored shape cannot
+        // match inside a longer identifier (`mytest_panel_defined_extra`).
+        {
+            pattern: `(?<![\\w-])test_${escapeRegex(oldTestStem)}_defined(?![\\w-])`,
+            to: `test_${newTestStem}_defined`,
+        },
+        // Word-boundary-aware, matching `furnace/rename.ts` and
+        // `rename-xpcshell.ts`: without the guards a rename of `moz-panel` rewrote
+        // `moz-panel-group`. `_` stays a legal neighbour for the underscored form
+        // because it is deliberately embedded in generated identifiers; `-` does
+        // not.
+        //
+        // Skipped when the underscored form IS the tag name (a hyphen-less
+        // component): both rules then match the same text and this one would win
+        // on order, substituting `newUnderscored` where the tag `newName` was
+        // meant. The stem rule still covers the one generated identifier shape.
+        ...(oldUnderscored === oldName
+            ? []
+            : [
+                {
+                    pattern: `(?<![A-Za-z0-9-])${escapeRegex(oldUnderscored)}(?![A-Za-z0-9-])`,
+                    to: newUnderscored,
+                },
+            ]),
+        { pattern: `(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, to: newName },
+        { pattern: `\\b${escapeRegex(oldClassName)}\\b`, to: newClassName },
+    ];
+    // Each alternative is its own capture group and the replacement is picked by
+    // the group that matched — not by matched TEXT, which is ambiguous whenever
+    // two rules can produce the same match with different substitutions.
+    const combined = new RegExp(alternatives.map(({ pattern }) => `(${pattern})`).join('|'), 'g');
+    return content.replace(combined, (matched, ...args) => {
+        const groups = args.slice(0, alternatives.length);
+        const index = groups.findIndex((group) => group !== undefined);
+        return alternatives[index]?.to ?? matched;
+    });
 }

package/dist/src/commands/furnace/scan.js

@@ -28,17 +28,10 @@ async function promptAddComponents(components, tracked, projectRoot) {
     }
     const selected = await multiselect({
         message: 'Select components to add as stock',
-        options: untrackedComponents.map((c) => {
-            const features = [];
-            if (c.hasCSS)
-                features.push('CSS');
-            if (c.hasFTL)
-                features.push('FTL');
-            if (c.isRegistered)
-                features.push('registered');
-            const label = features.length > 0 ? `${c.tagName} — ${features.join(', ')}` : c.tagName;
-            return { value: c.tagName, label };
-        }),
+        options: untrackedComponents.map((c) => ({
+            value: c.tagName,
+            label: `${c.tagName}${formatComponentFeatures(c)}`,
+        })),
     });
     if (isCancel(selected)) {
         cancel('Cancelled');
@@ -110,6 +103,22 @@ async function persistStockComponents(projectRoot, names) {
         }
     });
 }
+/**
+ * Renders a component's discovered capabilities as a display suffix.
+ * Written twice before 0.41.0 — once for the interactive multiselect labels
+ * and once for the report rows — which is part of what pinned
+ * `furnaceScanCommand` at complexity 30/30.
+ */
+function formatComponentFeatures(component) {
+    const features = [];
+    if (component.hasCSS)
+        features.push('CSS');
+    if (component.hasFTL)
+        features.push('FTL');
+    if (component.isRegistered)
+        features.push('registered');
+    return features.length > 0 ? ` — ${features.join(', ')}` : '';
+}
 /**
  * Runs the furnace scan command to discover MozLitElement components.
  * @param projectRoot - Root directory of the project
@@ -153,33 +162,15 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
             tracked.set(name, 'custom');
         }
     }
-    // Display each component
+    // Partition once and reuse: the tracked/untracked split was computed twice
+    // (imperatively here, declaratively again for --track) before 0.41.0.
+    const untrackedComponentList = components.filter((c) => !tracked.has(c.tagName));
+    const untrackedCount = untrackedComponentList.length;
+    const trackedCount = components.length - untrackedCount;
     for (const component of components) {
-        const features = [];
-        if (component.hasCSS)
-            features.push('CSS');
-        if (component.hasFTL)
-            features.push('FTL');
-        if (component.isRegistered)
-            features.push('registered');
-        let line = component.tagName;
-        if (features.length > 0) {
-            line += ` — ${features.join(', ')}`;
-        }
         const type = tracked.get(component.tagName);
-        if (type) {
-            line += ` [${type}]`;
-        }
-        info(line);
-    }
-    // Summary
-    let trackedCount = 0;
-    for (const component of components) {
-        if (tracked.has(component.tagName)) {
-            trackedCount++;
-        }
+        info(`${component.tagName}${formatComponentFeatures(component)}${type ? ` [${type}]` : ''}`);
     }
-    const untrackedCount = components.length - trackedCount;
     note(`Total: ${components.length}  Tracked: ${trackedCount}  Untracked: ${untrackedCount}`, 'Summary');
     // --track: persist the discovered untracked inventory into the `stock`
     // section without prompting (works non-interactively). Without it, scan
@@ -191,7 +182,7 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
             outro('Scan complete');
             return;
         }
-        const untrackedNames = components.filter((c) => !tracked.has(c.tagName)).map((c) => c.tagName);
+        const untrackedNames = untrackedComponentList.map((c) => c.tagName);
         await persistStockComponents(projectRoot, untrackedNames);
         success(`Tracked ${untrackedNames.length} component${untrackedNames.length === 1 ? '' : 's'} in the stock section of furnace.json`);
         outro('Scan complete');

package/dist/src/commands/furnace/status.js

@@ -157,42 +157,44 @@ export async function furnaceStatusCommand(projectRoot, name) {
     // hints, so report them separately rather than collapsing into a single
     // "something is off" message.
     if (await pathExists(paths.engine)) {
-        let workspaceChanged = false;
-        let engineDrifted = false;
-        for (const [oName, overrideConfig] of Object.entries(config.overrides)) {
-            const componentDir = join(furnacePaths.overridesDir, oName);
-            if (!(await pathExists(componentDir)))
-                continue;
-            const previous = extractComponentChecksums(state.appliedChecksums, 'override', oName);
-            if (await hasComponentChanged(componentDir, previous)) {
-                workspaceChanged = true;
-            }
-            else if (await hasOverrideEngineDrift(paths.engine, componentDir, overrideConfig, ftlDir)) {
-                engineDrifted = true;
-            }
-            if (workspaceChanged && engineDrifted)
-                break;
-        }
-        if (!(workspaceChanged && engineDrifted)) {
-            for (const [cName, customConfig] of Object.entries(config.custom)) {
-                const componentDir = join(furnacePaths.customDir, cName);
+        // Held in an object rather than two `let`s: the scanner below mutates
+        // them from inside a closure, and TS's control-flow analysis does not
+        // propagate that through the call — it would narrow both to the literal
+        // `false` and flag every later read as always-falsy.
+        const drift = { workspaceChanged: false, engineDrifted: false };
+        /**
+         * Scans one component family for workspace or engine drift.
+         *
+         * The engine probe sits behind `else if` deliberately: a component whose
+         * workspace already changed does not need an engine comparison to decide
+         * what `status` reports, and the probe is the expensive half (it re-hashes
+         * deployed files). The consequence is that engine drift can go UNREPORTED
+         * for a component that also has workspace changes — the summary says
+         * "workspace changed", not both. Preserved verbatim from the two
+         * hand-written copies this replaced.
+         */
+        const scanFamily = async (entries, baseDir, kind, probeEngineDrift) => {
+            for (const [componentName, componentConfig] of entries) {
+                if (drift.workspaceChanged && drift.engineDrifted)
+                    return;
+                const componentDir = join(baseDir, componentName);
                 if (!(await pathExists(componentDir)))
                     continue;
-                const previous = extractComponentChecksums(state.appliedChecksums, 'custom', cName);
+                const previous = extractComponentChecksums(state.appliedChecksums, kind, componentName);
                 if (await hasComponentChanged(componentDir, previous)) {
-                    workspaceChanged = true;
+                    drift.workspaceChanged = true;
                 }
-                else if (await hasCustomEngineDrift(projectRoot, cName, componentDir, customConfig, ftlDir)) {
-                    engineDrifted = true;
+                else if (await probeEngineDrift(componentName, componentDir, componentConfig)) {
+                    drift.engineDrifted = true;
                 }
-                if (workspaceChanged && engineDrifted)
-                    break;
             }
-        }
-        if (workspaceChanged) {
+        };
+        await scanFamily(Object.entries(config.overrides), furnacePaths.overridesDir, 'override', (_name, componentDir, cfg) => hasOverrideEngineDrift(paths.engine, componentDir, cfg, ftlDir));
+        await scanFamily(Object.entries(config.custom), furnacePaths.customDir, 'custom', (name, componentDir, cfg) => hasCustomEngineDrift(projectRoot, name, componentDir, cfg, ftlDir));
+        if (drift.workspaceChanged) {
             warn('Components have been modified since last apply. Run `fireforge build` or `fireforge furnace apply`.');
         }
-        if (engineDrifted) {
+        if (drift.engineDrifted) {
             warn('Engine drift detected since last apply (reset/download/manual edit). Run `fireforge furnace apply` to re-deploy.');
         }
     }

package/dist/src/commands/furnace/validate.js

@@ -6,6 +6,7 @@ import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../
 import { addCustomElementRegistration, addJarMnEntries, pruneStaleJarMnEntries, } from '../../core/furnace-registration.js';
 import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
 import { FurnaceError } from '../../errors/furnace.js';
+import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, note, outro, success, warn } from '../../utils/logger.js';
 import { displayValidationIssues } from './validation-output.js';
@@ -15,6 +16,7 @@ const FIXABLE_CHECKS = new Set([
     'missing-jar-mn-css',
     'wrong-registration-pattern',
     'stale-jar-registration',
+    'missing-custom-element-registration',
 ]);
 /**
  * Auto-fixes registration issues that have deterministic solutions.
@@ -53,7 +55,7 @@ async function autoFixIssues(projectRoot, issues) {
             }
         }
         catch (err) {
-            warn(`Could not prune stale jar.mn lines: ${err instanceof Error ? err.message : String(err)}`);
+            warn(`Could not prune stale jar.mn lines: ${toError(err).message}`);
         }
     }
     // Fix jar.mn entries
@@ -72,21 +74,26 @@ async function autoFixIssues(projectRoot, issues) {
             }
         }
         catch (err) {
-            warn(`Could not fix jar.mn for ${componentName}: ${err instanceof Error ? err.message : String(err)}`);
+            warn(`Could not fix jar.mn for ${componentName}: ${toError(err).message}`);
         }
     }
-    // Fix missing customElements.js registrations
-    for (const issue of issues) {
-        if (issue.check !== 'wrong-registration-pattern')
-            continue;
-        // wrong-registration-pattern means it IS registered, but in the wrong block.
-        // We don't auto-fix this as it requires moving code between blocks, which
-        // is too risky. Only fix truly missing registrations.
-    }
-    // Check for components that are missing from customElements.js entirely
-    // (detected by post-apply consistency, not by validate — but we can check here)
-    for (const [componentName, customConfig] of Object.entries(config.custom)) {
-        if (!customConfig.register)
+    // `wrong-registration-pattern` is deliberately NOT auto-fixed: it means the
+    // component IS registered but in the wrong block, and moving code between
+    // blocks is too risky to do unattended. Only truly missing registrations are
+    // repaired, below.
+    // Repair components missing from customElements.js entirely (reported by
+    // validate as `missing-custom-element-registration`).
+    //
+    // Scoped to the components named in `issues`. Until 0.41.0 this iterated
+    // every entry in `config.custom`, so `furnace validate <one-component> --fix`
+    // wrote customElements.js registrations for EVERY custom component — outside
+    // the issue list it was handed, and invisibly, since `fixed` was never
+    // incremented here. The block's own comment already claimed this scoping;
+    // the code did not implement it.
+    const componentsWithIssues = new Set(issues.map((issue) => issue.component));
+    for (const componentName of componentsWithIssues) {
+        const customConfig = config.custom[componentName];
+        if (!customConfig?.register)
             continue;
         const componentDir = join(furnacePaths.customDir, componentName);
         if (!(await pathExists(componentDir)))
@@ -97,13 +104,13 @@ async function autoFixIssues(projectRoot, issues) {
             continue;
         const modulePath = `chrome://global/content/elements/${componentName}.mjs`;
         try {
+            // Idempotent: returns without error when already registered, so this
+            // stays a no-op for components whose registration is already correct.
             await addCustomElementRegistration(engineDir, componentName, modulePath);
-            // addCustomElementRegistration is idempotent — it returns without error
-            // if already registered. We only count it as fixed if a matching issue
-            // existed in the input.
         }
         catch {
-            // Ignore — idempotent call, may already be registered
+            // Best-effort repair — the re-validation pass at the call site reports
+            // whatever is still outstanding.
         }
     }
     return fixed;

package/dist/src/commands/import.js

@@ -5,12 +5,13 @@ import { Command } from 'commander';
 import { getProjectPaths, loadConfig, loadState, updateState } from '../core/config.js';
 import { getHead } from '../core/git.js';
 import { getDirtyFiles } from '../core/git-status.js';
-import { applyPatchesWithContinue, countPatches, createPatchedContentComputer, discoverPatches, extractAffectedFiles, matchesUntilFilename, PatchError, } from '../core/patch-apply.js';
+import { applyPatchesWithContinue, countPatches, createPatchedContentContext, discoverPatches, extractAffectedFiles, matchesUntilFilename, PatchError, } from '../core/patch-apply.js';
 import { checkVersionCompatibility, loadPatchesManifest, validatePatchesManifestConsistency, validatePatchIntegrity, } from '../core/patch-manifest.js';
 import { getPatchSourceVersion } from '../core/patch-source-metadata.js';
 import { warnIfStaticComponentsStale } from '../core/test-stale-check.js';
 import { GeneralError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
+import { mapWithConcurrency } from '../utils/concurrency.js';
+import { getNodeErrorCode, toError } from '../utils/errors.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { error, info, intro, isCancel, outro, spinner, success, verbose, warn, } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
@@ -24,8 +25,8 @@ import { pickDefined } from '../utils/options.js';
  */
 const SAFE_IO_FALLBACK_CODES = new Set(['ENOENT', 'EACCES', 'EPERM', 'EISDIR', 'EBUSY']);
 function isSafeIoFallback(error) {
-    const code = error?.code;
-    return typeof code === 'string' && SAFE_IO_FALLBACK_CODES.has(code);
+    const code = getNodeErrorCode(error);
+    return code !== undefined && SAFE_IO_FALLBACK_CODES.has(code);
 }
 /** Concurrency bound for per-file classification (each call spawns git). */
 const UNMANAGED_CLASSIFY_CONCURRENCY = 8;
@@ -33,7 +34,7 @@ async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
     // One manifest+patch-discovery load for the whole batch (the per-call
     // computePatchedContent re-read everything for every file), and bounded
     // concurrency instead of an unbounded Promise.all over git spawns.
-    const computeExpected = await createPatchedContentComputer(patchesDir, engineDir);
+    const { computePatched: computeExpected } = await createPatchedContentContext(patchesDir, engineDir);
     const classifications = await mapWithConcurrency(dirtyFiles, UNMANAGED_CLASSIFY_CONCURRENCY, async (file) => {
         try {
             const [expected, exists] = await Promise.all([
@@ -62,21 +63,6 @@ async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
     });
     return classifications.filter((file) => file !== null).sort();
 }
-/** Maps items with at most `limit` in-flight promises. Preserves order. */
-async function mapWithConcurrency(items, limit, fn) {
-    const results = new Array(items.length);
-    let next = 0;
-    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-        for (;;) {
-            const index = next++;
-            if (index >= items.length)
-                return;
-            results[index] = await fn(items[index]);
-        }
-    });
-    await Promise.all(workers);
-    return results;
-}
 function reportForcedOverwriteRisk(unmanagedDirtyFiles) {
     warn(`--force will overwrite ${unmanagedDirtyFiles.length} unmanaged change${unmanagedDirtyFiles.length === 1 ? '' : 's'} in patch-touched file${unmanagedDirtyFiles.length === 1 ? '' : 's'}:`);
     for (const file of unmanagedDirtyFiles) {

package/dist/src/commands/lint-per-patch.js

@@ -3,14 +3,14 @@ import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, getPerPatchLintCacheHeadSha, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/lint-cache.js';
-import { buildPatchQueueContext, countNonBinaryDiffLines, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
-import { invokePatchLintCheckJsGrouped, runCheckJsTestFilesGrouped, } from '../core/patch-lint-checkjs.js';
-import { isTestScriptFile, resolvePatchOwnedSysMjs, resolvePatchOwnedTestScripts, } from '../core/patch-lint-ownership.js';
+import { buildPatchQueueContext, countNonBinaryDiffLines, formatPatchLintIssue, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { evaluatePatchPolicy } from '../core/patch-policy.js';
 import { GeneralError } from '../errors/base.js';
+import { mapWithConcurrency } from '../utils/concurrency.js';
 import { pathExists } from '../utils/fs.js';
 import { info, outro, success, warn } from '../utils/logger.js';
+import { buildPerRunCheckJs } from './lint-per-run-checkjs.js';
 import { writePerPatchLintReport } from './lint-report.js';
 function buildPerPatchMaxWarningsMessage(count, maxWarnings, linted) {
     return (`Patch lint found ${count} warning(s) across ${linted} patch(es), exceeding --max-warnings ${maxWarnings}.` +
@@ -34,11 +34,8 @@ function emitTierNotice(filename, files, tier) {
  */
 async function lintQueuedPatch(patch, lintCtx) {
     const { projectRoot, paths, config, ctx, cache, engineHeadSha } = lintCtx;
-    const existing = [];
-    for (const f of patch.filesAffected) {
-        if (await pathExists(join(paths.engine, f)))
-            existing.push(f);
-    }
+    const present = await mapWithConcurrency(patch.filesAffected, 8, (f) => pathExists(join(paths.engine, f)));
+    const existing = patch.filesAffected.filter((_, index) => present[index] === true);
     if (existing.length === 0) {
         return {
             status: 'skipped',
@@ -237,11 +234,11 @@ function reportPerPatchOutcome(issues, linted, skipped, options) {
     const warnings = issues.filter((i) => i.severity === 'warning');
     const notices = issues.filter((i) => i.severity === 'notice');
     for (const issue of notices)
-        info(`NOTICE [${issue.check}] ${issue.file}: ${issue.message}`);
+        info(`NOTICE ${formatPatchLintIssue(issue)}`);
     for (const issue of warnings)
-        warn(`[${issue.check}] ${issue.file}: ${issue.message}`);
+        warn(formatPatchLintIssue(issue));
     for (const issue of errors)
-        warn(`ERROR [${issue.check}] ${issue.file}: ${issue.message}`);
+        warn(`ERROR ${formatPatchLintIssue(issue)}`);
     info(`\nLint (per-patch over ${linted} patch(es)): ${errors.length} error(s), ${warnings.length} warning(s)`);
     if (errors.length > 0) {
         outro('Lint failed');
@@ -305,53 +302,6 @@ function selectPatchSubset(manifest, requested) {
     }
     return selected;
 }
-/**
- * Builds the per-run checkJs program controller when `patchLint.checkJs` is
- * enabled, or returns undefined. The program is built lazily on the first
- * cache miss (so an all-warm run never pays for it) and reused for every
- * subsequent patch in the run.
- */
-function buildPerRunCheckJs(projectRoot, paths, config, ctx) {
-    const patchLint = config.patchLint;
-    if (!patchLint?.checkJs)
-        return undefined;
-    const testFilesEnabled = patchLint.checkJsTestFiles === true;
-    const ownedByPatch = new Map();
-    for (const entry of ctx.entries) {
-        const owned = new Set();
-        for (const f of entry.newFiles.keys()) {
-            if (f.endsWith('.sys.mjs'))
-                owned.add(f);
-            else if (testFilesEnabled && isTestScriptFile(f))
-                owned.add(f);
-        }
-        if (owned.size > 0)
-            ownedByPatch.set(entry.filename, owned);
-    }
-    // One build for the whole run: the queue-wide `.sys.mjs` program plus —
-    // when `patchLint.checkJsTestFiles` is on (FORGE G5) — one small
-    // script-scope program per patch-owned test file, merged by file.
-    const buildAll = async () => {
-        const sys = await invokePatchLintCheckJsGrouped(paths.engine, resolvePatchOwnedSysMjs(new Set(), ctx), patchLint, projectRoot);
-        if (!testFilesEnabled)
-            return sys;
-        const tests = await runCheckJsTestFilesGrouped(paths.engine, resolvePatchOwnedTestScripts(new Set(), ctx), patchLint, projectRoot);
-        const byFile = new Map(sys.byFile);
-        for (const [rel, list] of tests.byFile) {
-            byFile.set(rel, [...(byFile.get(rel) ?? []), ...list]);
-        }
-        return { byFile, global: [...sys.global, ...tests.global] };
-    };
-    // Memoise the *promise*, not the resolved value: under the bounded pool
-    // several patches can reach `getGrouped` before the first build resolves, and
-    // `??=` on the promise (a synchronous expression) guarantees a single build.
-    let groupedPromise;
-    return {
-        ownedByPatch,
-        getGrouped: () => (groupedPromise ??= buildAll()),
-        getGlobal: async () => (await (groupedPromise ??= buildAll())).global,
-    };
-}
 /**
  * Lints each patch in the queue as its own isolated diff, honouring
  * per-patch `lintIgnore` entries. Cross-patch rules still run once over
@@ -400,7 +350,10 @@ export async function lintPerPatch(projectRoot, paths, options = {}) {
             severity: issue.severity,
         });
     }
-    const checkJs = buildPerRunCheckJs(projectRoot, paths, config, ctx);
+    // With `--patches`, the checkJs program roots at only the subset's owned
+    // files — the full queue stays resolvable, so a cold subset run costs the
+    // subset's import closure instead of the whole queue (FORGE J1c).
+    const checkJs = buildPerRunCheckJs(projectRoot, paths, config, ctx, isSubset ? subsetNames : undefined);
     // Lint patches concurrently, then apply every side effect in patch order so
     // the issue rows, the run-level checkJs errors, and the saved cache are
     // identical to a serial run.

package/dist/src/commands/lint-per-run-checkjs.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Per-run checkJs program controller, shared by `lint --per-patch` and
+ * `re-export` (FORGE J1).
+ *
+ * The dominant fixed cost of patch lint is one `ts.createProgram` over the
+ * queue's patch-owned `.sys.mjs` files (~37 s on a 290-patch consumer
+ * queue). This controller builds that program at most ONCE per command
+ * invocation (lazily, promise-memoised) and lets callers slice per-patch
+ * findings out of the grouped result. Three levers keep the cost paid only
+ * when it buys something:
+ *
+ * - **Lazy build**: nothing is built until the first cache miss asks.
+ * - **Root scoping** (`rootScopePatches`): with `--patches <subset>` the
+ *   program's roots are only the subset's owned files; the full queue
+ *   stays resolvable, so cross-patch imports type-check identically while
+ *   unrelated files are never parsed (FORGE J1c).
+ * - **Warm-run probe**: run-level ("global") checkJs findings come only
+ *   from a missing `typescript` package or an unreadable shim — never
+ *   from the built program — so an all-cache-hit run satisfies "warm
+ *   never reports less than cold" (FORGE F5) via
+ *   `probeCheckJsGlobalIssues` instead of building anything.
+ */
+import type { getProjectPaths, loadConfig } from '../core/config.js';
+import { type GroupedCheckJsResult } from '../core/patch-lint-checkjs.js';
+import type { PatchQueueContext } from '../core/patch-lint-cross.js';
+import type { PatchLintIssue } from '../types/commands/index.js';
+/**
+ * Queue-wide checkJs program built once per run and sliced per patch, so a
+ * single type regression surfaces once against its owning patch instead of
+ * being duplicated for every patch in the queue.
+ */
+export interface PerRunCheckJs {
+    /** Patch filename → the checkJs-relevant files that patch creates. */
+    ownedByPatch: Map<string, Set<string>>;
+    /** Every checkJs-relevant file in the queue (sys + test scripts) — the
+     *  resolution universe the program can see. Callers use it to detect
+     *  files the hoisted program has never heard of (fresh `--scan`
+     *  adoptions) and fall back to a per-patch build. */
+    resolutionSet: ReadonlySet<string>;
+    /** Builds (once, lazily on first cache miss) and returns the grouped run.
+     *  Promise-memoised so the bounded per-patch pool builds the program exactly
+     *  once even when several patches reach it concurrently. */
+    getGrouped: () => Promise<GroupedCheckJsResult>;
+    /** Run-level checkJs errors (e.g. TypeScript missing). When the program
+     *  was never built (all-warm run) this probes the two global failure
+     *  sources directly instead of building it — FORGE F5 holds because the
+     *  built program never contributes globals of its own. */
+    getGlobal: () => Promise<PatchLintIssue[]>;
+    /** The byFile slices for `files` (globals deliberately EXCLUDED — they
+     *  are run-level, never cached, and emitted once per invocation via
+     *  `getGlobal`). Feed to `LintExportedPatchOptions.precomputedCheckJs`. */
+    sliceFor: (files: ReadonlySet<string>) => Promise<PatchLintIssue[]>;
+    /** True when this file kind participates in the run's checkJs surface
+     *  (`.sys.mjs`, plus test scripts when `checkJsTestFiles` is on). */
+    isRelevant: (file: string) => boolean;
+}
+/**
+ * Builds the per-run checkJs program controller when `patchLint.checkJs` is
+ * enabled, or returns undefined. With `rootScopePatches` set (the
+ * `--patches` subset, by patch filename), the program roots at only the
+ * subset's owned files and the test-file pass runs only the subset's own
+ * scripts (head.js discovery still spans the queue).
+ */
+export declare function buildPerRunCheckJs(projectRoot: string, paths: ReturnType<typeof getProjectPaths>, config: Awaited<ReturnType<typeof loadConfig>>, ctx: PatchQueueContext, rootScopePatches?: ReadonlySet<string>): PerRunCheckJs | undefined;