@hominis/fireforge 0.50.0 → 0.51.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.51.0
+
+### Test harness
+
+- `started=` counts start lines as the output streams, or reads the mozlog raw log when the run wrote one. A suite printing more than 2 MB, or any `--full-output` run, no longer reports files that ran as unstarted. A refusal names its evidence with `started-source=`.
+- Sharded runs print a `FIREFORGE-SHARD:` line per shard and `failed-shards=` on the verdict. New `--shard-size <n>` runs n files per mach invocation, judged per file. New `--results <path>` writes per-file JSON (status, expected, duration, log offset) from mozlog and adds `results=` to the verdict.
+- Negative controls accept a plain unified diff, and a `git diff --no-index` against an edited copy. A control on compiled source is refused without `--build`. With `--build` it goes in before the build and is restored afterwards (`control-build=compiled`). A build-less control on stale packaging is refused before the lock.
+- Mid-run engine edits the running browser cannot see no longer make a run inconclusive (`drift-tolerated=<n>`). A scoped `--build` of one file keeps its manifest siblings' coverage, and packaging refusals arrive before the lock.
+- `--furnace-apply all|reached|none` and `test.furnaceApply` scope the pre-test Furnace apply; components left out are named in `furnace-skipped=`. The default stays `all`.
+
+### Locks
+
+- New opt-in `--shared-lock` and `test.lockMode: "shared"` let build-less test runs with auto ports overlap on one objdir; builds, re-exports and every other writer stay exclusive. New `test --jobs <n>` runs a request's shards on n harness instances inside one hold, each on its own ports, with `[job i]`-prefixed output.
+- `--wait-lock` and `FIREFORGE_WAIT_LOCK` accept up to 86400 seconds.
+
+### Patch queue
+
+- Added `patch reserve <order>`, which holds a claimed order under `allowGaps: false`; default allocation skips it, and the export that takes it fills it. Added `patch stage <name>...`, which stages only the named patches' rows of `patches.json` (validated) and their patch files. Every writer emits one canonical `patches.json` key order, so the first full save may reorder keys once.
+- Added `re-export --hunks-from <diff>` and `--exclude-hunks <diff>`, which export a shared file hunk by hunk. Added `fireforge park`, which sets a session's edits to a patch's files aside and merges them back three-way, warning about Fluent ids and files still referenced outside the patch.
+- `re-export --dry-run` takes no engine lock and runs on a private git index. Its purity guard covers only the selected patches, their rows and the engine files they own, and names a concurrent writer instead of calling a peer's write a FireForge bug.
+- Refused `re-export --scan`, `patch move-files` and `patch split` write one `--from`-ready declaration report (`--declarations-out`) and name one `staged-dependency --add --from` call per holding patch. `--refuse-adjacent-unmanaged` combines with `--scan`.
+- `staged-dependency --remove` accepts `--creates` alone, matches registration lines regardless of whitespace, and exits 8 when nothing matches. Re-export drops a staged registration whose `creates` path no patch owns. An `--expect-removed` path owned by an unselected patch names that owner.
+- `patch delete` and `retire` name created files still on disk and gain `--delete-created`. A description-only `patch rename` needs no `--yes`.
+- An unscoped `verify`, and so `fireforge check`, also reads unexported engine files for imports of unregistered `resource:///modules` modules.
+
+### Lint and tokens
+
+- `lintIgnore` ceilings take a free-form `meta` object and `share: "test"|"product"`, and a notice no longer exceeds a ceiling. `lint --report` adds `lintIgnoreWaivers` for bare waivers. `patch lint-ignore` gains `--add <rule>=<max>`, `--share` and `--from <json|report>`.
+- `patchLint.tokenScales` skips `@font-face` and other descriptor at-rules. Each scale also takes a `prefix` list, `allowInCalc`, `offsetCap`, `exclude` globs and a `minFiles` floor (`token-scale-vacuous`). `token lint` treats a `var()` with a fallback as optional and resolves tokens declared by sibling sheets: from document links, from `@import`, or from `furnace.json#tokenSiblingSheets`.
+- A test script's per-patch checkJs resolves modules created by earlier patches. Opt-in `typecheck.litTypes` types `LitElement` and `MozLitElement`. A scoped `lint --per-patch --patches` keeps stale staged declarations. `discoverPatches` follows symlinked patch files.
+- The API exports `measurePatchSize`, `isPatchSizeRegistrationFile`, `codeLineMask` and `evaluatePatchPolicyContentForQueue`.
+
+### Gates
+
+- `fireforge check` gains `check.timeout` and `check.timeouts.<step>` for built-in steps, `check.failOnSkipped`, `check.lintReport` (passed to extra steps as `FIREFORGE_CHECK_LINT_REPORT`), and `extraSteps[].after`. The verdict line names `skipped-steps=`.
+
+### Furnace
+
+- `furnace validate`: an exception no longer suppresses an error (`validation-exception-on-error`), and an exception can name a `tag`. `minComponents` sets a floor (`component-floor`). `panel-item` counts as natively interactive, and the accessibility checks judge the host module together with its companion modules.
+- `furnace deploy` and `furnace rename` edit `jar.mn` lines in place instead of re-sorting the widget's block.
+- The `icon-button-label` check scans a button's content for text outside tags instead of stripping tags with a regex. A `>` inside a quoted attribute no longer ends the tag.
+
+### Other
+
+- Windows: when two commands race to migrate the legacy history log, the loser stands down instead of failing on a claim the other command holds. The `check` process test no longer assumes a POSIX shell, and the `build` and `test` pre-lock tests no longer assume POSIX paths.
+- Dev tooling: `@types/node` 26.6.5, `@vitest/coverage-v8` and `vitest` 5.0.5, `eslint-plugin-jsdoc` 65.3.6, `knip` 6.41.0, `prettier` 3.9.10, `typescript-eslint` 8.71.2 and `vite` 8.3.4. Runtime: `acorn` 8.19.0 and `magic-string` 1.4.3. CI: `actions/setup-node` 7.1.0 and `github/codeql-action` 4.38.3.
+
 ## 0.50.0
 
 ### Size budget

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "version": "0.50.0",
-  "commit": "996c59a67aa2144ff889a8c47e9304b071afae81",
-  "shortCommit": "996c59a67aa2",
+  "version": "0.51.0",
+  "commit": "bd93338b037832fdcd69259a70a3a4b134b98906",
+  "shortCommit": "bd93338b0378",
   "dirty": false,
   "dirtyHash": null,
-  "buildTime": "2026-10-12T00:43:41.476Z"
+  "buildTime": "2026-10-19T12:33:48.474Z"
 }

package/dist/src/commands/check-report.d.ts

@@ -3,8 +3,15 @@ import type { CheckStepResult } from './check-run.js';
  * Why a check failed. `step-failures`: at least one step went red.
  * `lock-timeout`: every failing step exited 15, so nothing was judged red,
  * the steps just never got their locks. Re-queue rather than fix.
+ * `skipped-steps`: nothing went red, but `check.failOnSkipped` is set and a
+ * step had nothing to run.
  */
-export type CheckVerdictReason = 'step-failures' | 'lock-timeout';
+export type CheckVerdictReason = 'step-failures' | 'lock-timeout' | 'skipped-steps';
+/** How the verdict treats skipped steps. */
+export interface CheckJudgeOptions {
+    /** `check.failOnSkipped`: a step skipped for want of anything to run fails the check. */
+    failOnSkipped?: boolean | undefined;
+}
 /** The verdict over all steps. */
 export interface CheckVerdict {
     passed: boolean;
@@ -13,11 +20,17 @@ export interface CheckVerdict {
     skipped: string[];
     steps: number;
 }
-/** Judges the results: any failing step fails the check. */
-export declare function judgeCheck(results: readonly CheckStepResult[]): CheckVerdict;
+/**
+ * Judges the results: any failing step fails the check. Under
+ * `failOnSkipped`, so does a step skipped because the project has nothing
+ * for it to run; it is then listed in `failed` too.
+ */
+export declare function judgeCheck(results: readonly CheckStepResult[], options?: CheckJudgeOptions): CheckVerdict;
 /**
  * The verdict line: `FIREFORGE-VERDICT: PASS steps=<n> skipped=<n>` or
- * `FIREFORGE-VERDICT: FAIL reason=<reason> failed=<a,b> steps=<n> skipped=<n>`.
+ * `FIREFORGE-VERDICT: FAIL reason=<reason> failed=<a,b> steps=<n> skipped=<n>`,
+ * with an additive `skipped-steps=<a,b>` naming the skipped steps when
+ * there are any.
  */
 export declare function formatCheckVerdictLine(verdict: CheckVerdict): string;
 /** The per-step table: one aligned row per step, with its detail. */

package/dist/src/commands/check-report.js

@@ -8,12 +8,19 @@
 import { setStdoutSealed } from '../utils/logger.js';
 /** Exit code a step reports when its lock wait expired. */
 const LOCK_TIMEOUT_EXIT = 15;
-/** Judges the results: any failing step fails the check. */
-export function judgeCheck(results) {
+/**
+ * Judges the results: any failing step fails the check. Under
+ * `failOnSkipped`, so does a step skipped because the project has nothing
+ * for it to run; it is then listed in `failed` too.
+ */
+export function judgeCheck(results, options = {}) {
     const failedResults = results.filter((result) => result.status === 'fail');
+    const gaps = options.failOnSkipped === true
+        ? results.filter((result) => result.status === 'skipped' && result.skipKind !== 'config')
+        : [];
     const verdict = {
-        passed: failedResults.length === 0,
-        failed: failedResults.map((result) => result.name),
+        passed: failedResults.length === 0 && gaps.length === 0,
+        failed: [...failedResults, ...gaps].map((result) => result.name),
         skipped: results.filter((result) => result.status === 'skipped').map((result) => result.name),
         steps: results.length,
     };
@@ -22,14 +29,20 @@ export function judgeCheck(results) {
             ? 'lock-timeout'
             : 'step-failures';
     }
+    else if (gaps.length > 0) {
+        verdict.reason = 'skipped-steps';
+    }
     return verdict;
 }
 /**
  * The verdict line: `FIREFORGE-VERDICT: PASS steps=<n> skipped=<n>` or
- * `FIREFORGE-VERDICT: FAIL reason=<reason> failed=<a,b> steps=<n> skipped=<n>`.
+ * `FIREFORGE-VERDICT: FAIL reason=<reason> failed=<a,b> steps=<n> skipped=<n>`,
+ * with an additive `skipped-steps=<a,b>` naming the skipped steps when
+ * there are any.
  */
 export function formatCheckVerdictLine(verdict) {
-    const counts = `steps=${verdict.steps} skipped=${verdict.skipped.length}`;
+    const skippedNames = verdict.skipped.length > 0 ? ` skipped-steps=${verdict.skipped.join(',')}` : '';
+    const counts = `steps=${verdict.steps} skipped=${verdict.skipped.length}${skippedNames}`;
     if (verdict.passed)
         return `FIREFORGE-VERDICT: PASS ${counts}`;
     return `FIREFORGE-VERDICT: FAIL reason=${verdict.reason ?? 'step-failures'} failed=${verdict.failed.join(',')} ${counts}`;

package/dist/src/commands/check-run.d.ts

@@ -6,6 +6,11 @@ export interface CheckStepResult {
     /** The command line, as the table prints it. */
     command: string;
     status: 'pass' | 'fail' | 'skipped';
+    /**
+     * For a skipped step: `config` when `check.skip` names it, `unavailable`
+     * when the project has nothing for it to run.
+     */
+    skipKind?: 'config' | 'unavailable';
     /** The child's exit code. Null when it never ran or was killed at its budget. */
     exitCode: number | null;
     durationMs: number;

package/dist/src/commands/check-run.js

@@ -19,7 +19,14 @@ function tailLines(text) {
 async function runStep(plan, now) {
     const base = { name: plan.name, kind: plan.kind, command: plan.display };
     if (plan.skipReason !== undefined) {
-        return { ...base, status: 'skipped', exitCode: null, durationMs: 0, detail: plan.skipReason };
+        return {
+            ...base,
+            status: 'skipped',
+            skipKind: plan.skipKind ?? 'unavailable',
+            exitCode: null,
+            durationMs: 0,
+            detail: plan.skipReason,
+        };
     }
     let stdout = '';
     let combined = '';
@@ -34,6 +41,7 @@ async function runStep(plan, now) {
             cwd: plan.cwd,
             processGroup: true,
             ...(plan.timeoutMs !== undefined ? { timeout: plan.timeoutMs } : {}),
+            ...(plan.env !== undefined ? { env: plan.env } : {}),
             onStdout: (chunk) => {
                 stdout += chunk;
                 append(chunk);

package/dist/src/commands/check-steps.d.ts

@@ -15,6 +15,14 @@ export interface CheckStepPlan {
     after: string[];
     /** Set when the step is planned but not run, with the reason. */
     skipReason?: string | undefined;
+    /**
+     * Why it is skipped: `config` when `check.skip` names it (a decision),
+     * `unavailable` when the project has nothing for it to run (a gap,
+     * which `check.failOnSkipped` fails).
+     */
+    skipKind?: 'config' | 'unavailable' | undefined;
+    /** Extra environment for the child. */
+    env?: Record<string, string> | undefined;
     /** Condenses a finished run into the table's detail cell. */
     summarize: (output: {
         stdout: string;

package/dist/src/commands/check-steps.js

@@ -110,11 +110,18 @@ function builtinStep(invocation, projectRoot, name, args, summarize, extra = {})
         args: [...invocation.prefix, ...args],
         display: `fireforge ${args.join(' ')}`,
         cwd: projectRoot,
+        timeoutMs: extra.timeoutMs,
         after: extra.after ?? [],
         skipReason: extra.skipReason,
+        skipKind: extra.skipReason !== undefined ? 'unavailable' : undefined,
         summarize,
     };
 }
+/** A built-in step's budget: `check.timeouts.<step>`, else `check.timeout`. */
+function builtinTimeoutMs(check, name) {
+    const seconds = check.timeouts?.[name] ?? check.timeout;
+    return seconds !== undefined ? seconds * 1000 : undefined;
+}
 /** Runs a project command line through the platform shell. */
 function shellInvocation(commandLine) {
     return process.platform === 'win32'
@@ -139,18 +146,33 @@ export function buildCheckPlan(input) {
     const furnaceWarnings = check.maxWarnings?.furnace !== undefined
         ? ['--max-warnings', String(check.maxWarnings.furnace)]
         : [];
+    const lintReport = check.lintReport !== undefined ? join(projectRoot, check.lintReport) : undefined;
+    const lintReportArgs = lintReport !== undefined ? ['--report', lintReport] : [];
+    const timeoutMs = (name) => builtinTimeoutMs(check, name);
     const plan = [
-        builtinStep(invocation, projectRoot, 'status', ['status', '--json', '--summary', '--check', ...statusPolicyArgs(check.status), ...patchArgs], summarizeStatus),
-        builtinStep(invocation, projectRoot, 'verify', ['verify', ...patchArgs], generic),
-        builtinStep(invocation, projectRoot, 'lint', ['lint', '--per-patch', '--notices', 'summary', ...lintWarnings, ...patchArgs], generic),
+        builtinStep(invocation, projectRoot, 'status', ['status', '--json', '--summary', '--check', ...statusPolicyArgs(check.status), ...patchArgs], summarizeStatus, { timeoutMs: timeoutMs('status') }),
+        builtinStep(invocation, projectRoot, 'verify', ['verify', ...patchArgs], generic, {
+            timeoutMs: timeoutMs('verify'),
+        }),
+        builtinStep(invocation, projectRoot, 'lint', [
+            'lint',
+            '--per-patch',
+            '--notices',
+            'summary',
+            ...lintWarnings,
+            ...lintReportArgs,
+            ...patchArgs,
+        ], generic, { timeoutMs: timeoutMs('lint') }),
         builtinStep(invocation, projectRoot, 'typecheck', ['typecheck'], generic, {
             skipReason: config.typecheck === undefined ? 'no "typecheck" block in fireforge.json' : undefined,
+            timeoutMs: timeoutMs('typecheck'),
         }),
         builtinStep(invocation, projectRoot, 'furnace-validate', ['furnace', 'validate', '--json', ...furnaceWarnings], summarizeFurnace, {
             after: ['typecheck'],
             skipReason: input.furnaceConfigured ? undefined : 'no furnace.json',
+            timeoutMs: timeoutMs('furnace-validate'),
         }),
-        builtinStep(invocation, projectRoot, 'token-coverage', ['token', 'coverage'], summarizeTokenCoverage),
+        builtinStep(invocation, projectRoot, 'token-coverage', ['token', 'coverage'], summarizeTokenCoverage, { timeoutMs: timeoutMs('token-coverage') }),
     ];
     for (const step of check.extraSteps ?? []) {
         const shell = shellInvocation(step.command);
@@ -162,14 +184,17 @@ export function buildCheckPlan(input) {
             display: step.command,
             cwd: step.cwd !== undefined ? join(projectRoot, step.cwd) : projectRoot,
             timeoutMs: step.timeout !== undefined ? step.timeout * 1000 : undefined,
-            after: [],
+            after: step.after ?? [],
+            env: lintReport !== undefined ? { FIREFORGE_CHECK_LINT_REPORT: lintReport } : undefined,
             summarize: generic,
         });
     }
     for (const name of check.skip ?? []) {
         const step = plan.find((entry) => entry.name === name);
-        if (step !== undefined)
+        if (step !== undefined) {
             step.skipReason = 'skipped by check.skip in fireforge.json';
+            step.skipKind = 'config';
+        }
     }
     return plan;
 }

package/dist/src/commands/check.js

@@ -123,7 +123,7 @@ async function runCheck(projectRoot, options) {
     const runnable = plan.filter((step) => step.skipReason === undefined).length;
     info(`Running ${runnable} step(s), up to ${Math.min(jobs, Math.max(1, runnable))} at once${patches ? `, judging ${patches.join(', ')}` : ''}.`);
     const results = await runCheckSteps(plan, jobs);
-    const verdict = judgeCheck(results);
+    const verdict = judgeCheck(results, { failOnSkipped: config.check?.failOnSkipped });
     if (options.json === true) {
         writeCheckJson(results, verdict);
     }

package/dist/src/commands/declarations-report.d.ts

@@ -0,0 +1,43 @@
+import type { ConflictReport } from '../core/destructive.js';
+import type { PatchLintIssue, PatchLintStagedDeclaration } from '../types/commands/index.js';
+/** A written declaration report and the commands that apply it. */
+export interface DeclarationsReport {
+    /** Absolute path of the JSON report. */
+    path: string;
+    /** Declarations written. */
+    count: number;
+    /** One `patch staged-dependency <holder> --add --from` call per holder. */
+    commands: string[];
+}
+/**
+ * A declaration as the report records it. `owner` is dropped when it names
+ * a patch the refused change would have created, which does not exist yet.
+ */
+export type ReportedDeclaration = Omit<PatchLintStagedDeclaration, 'owner'> & {
+    owner?: string;
+};
+/** Rewrites a projected declaration into the names the current queue uses. */
+export type DeclarationRenamer = (declaration: PatchLintStagedDeclaration) => ReportedDeclaration;
+/**
+ * Writes every declaration `issues` propose into one report, or returns
+ * undefined when they propose none.
+ *
+ * @param projectRoot - Project root (the default report directory lives under it)
+ * @param issues - The refusal's findings
+ * @param out - `--declarations-out`, relative to the working directory
+ * @param rename - Maps projected patch names back to current ones
+ */
+export declare function writeDeclarationsReport(projectRoot: string, issues: readonly PatchLintIssue[], out?: string, rename?: DeclarationRenamer): Promise<DeclarationsReport | undefined>;
+/** The refusal lines that point at a written report. */
+export declare function formatDeclarationsReport(report: DeclarationsReport): string[];
+/**
+ * Appends the report lines to a refusal, writing the report from the
+ * refusal's findings. A refusal that proposes no declaration is returned
+ * unchanged, and so is no refusal at all.
+ */
+export declare function withDeclarationsReport(conflicts: ConflictReport | null, args: {
+    projectRoot: string;
+    regressions: readonly PatchLintIssue[];
+    out?: string | undefined;
+    rename?: DeclarationRenamer;
+}): Promise<ConflictReport | null>;

package/dist/src/commands/declarations-report.js

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * One `--from`-ready declaration report for a refused queue change.
+ *
+ * Moving a test out of a patch that owns a shared manifest refused with one
+ * `forward-registration` error per manifest line, and each line needed its
+ * own `patch staged-dependency --add` call: a slice that added seven suites
+ * wrote eighteen declarations by hand. `patch move-files`, `patch split`
+ * and `re-export --scan` now write every declaration their refusal proposes
+ * into one lint-report-shaped JSON (`queueIssues[].stagedDeclarations`) and
+ * name the single `patch staged-dependency <holder> --add --from <file>`
+ * call per holding patch that discharges them.
+ */
+import { join, resolve } from 'node:path';
+import { STAGED_DEPENDENCY_REASON_PLACEHOLDER } from '../core/patch-lint-staged-registration.js';
+import { ensureDir, writeJson } from '../utils/fs.js';
+/** Where an unnamed report goes, relative to the project root. */
+const DEFAULT_REPORT_DIR = join('.fireforge', 'declarations');
+/** The checks whose findings carry declarations that discharge them. */
+const DECLARABLE_CHECKS = new Set(['forward-import', 'forward-registration']);
+/**
+ * Writes every declaration `issues` propose into one report, or returns
+ * undefined when they propose none.
+ *
+ * @param projectRoot - Project root (the default report directory lives under it)
+ * @param issues - The refusal's findings
+ * @param out - `--declarations-out`, relative to the working directory
+ * @param rename - Maps projected patch names back to current ones
+ */
+export async function writeDeclarationsReport(projectRoot, issues, out, rename = (declaration) => declaration) {
+    const queueIssues = issues
+        .filter((issue) => DECLARABLE_CHECKS.has(issue.check))
+        .map((issue) => ({
+        check: issue.check,
+        file: issue.file,
+        message: issue.message,
+        stagedDeclarations: (issue.stagedDeclarations ?? []).map(rename),
+    }))
+        .filter((issue) => issue.stagedDeclarations.length > 0);
+    const declarations = queueIssues.flatMap((issue) => issue.stagedDeclarations);
+    if (declarations.length === 0)
+        return undefined;
+    const path = out !== undefined
+        ? resolve(out)
+        : join(projectRoot, DEFAULT_REPORT_DIR, `${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}.json`);
+    await ensureDir(resolve(path, '..'));
+    await writeJson(path, { queueIssues });
+    const holders = [...new Set(declarations.map((declaration) => declaration.patch))].sort();
+    return {
+        path,
+        count: declarations.length,
+        commands: holders.map((holder) => `fireforge patch staged-dependency ${holder} --add --from ${path} ` +
+            STAGED_DEPENDENCY_REASON_PLACEHOLDER),
+    };
+}
+/** The refusal lines that point at a written report. */
+export function formatDeclarationsReport(report) {
+    return [
+        `All ${report.count} declaration(s) this refusal proposes are in ${report.path}; ` +
+            'declare them in one call per holding patch:',
+        ...report.commands.map((command) => `  ${command}`),
+    ];
+}
+/**
+ * Appends the report lines to a refusal, writing the report from the
+ * refusal's findings. A refusal that proposes no declaration is returned
+ * unchanged, and so is no refusal at all.
+ */
+export async function withDeclarationsReport(conflicts, args) {
+    if (conflicts === null)
+        return null;
+    const report = await writeDeclarationsReport(args.projectRoot, args.regressions, args.out, args.rename);
+    if (report === undefined)
+        return conflicts;
+    return { ...conflicts, details: [...conflicts.details, ...formatDeclarationsReport(report)] };
+}

package/dist/src/commands/export-placement-gate.js

@@ -8,6 +8,7 @@
 import { confirmDestructive } from '../core/destructive.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { applyRenameMapToManifest, buildProjectedManifest, enforcePatchPolicy, } from '../core/patch-policy.js';
+import { reservationAt } from '../core/patch-retired.js';
 import { buildPatchSourceMetadata } from '../core/patch-source-metadata.js';
 import { InvalidArgumentError } from '../errors/base.js';
 import { proceedAfterDecision } from './destructive-decision.js';
@@ -68,6 +69,13 @@ export async function gatePlacementPlan(args) {
         forceUnsafe: options.forceUnsafe === true,
     });
     const summary = placementSummary(placementPlan);
+    const reservation = reservationAt(currentManifest, placementPlan.insertionOrder);
+    if (reservation !== undefined) {
+        const notice = `order ${placementPlan.insertionOrder} is reserved by ${reservation.owner}; ` +
+            'this export fills the reservation';
+        summary.push(notice);
+        s.message(notice);
+    }
     const renameCount = placementPlan.renameMap.size;
     // Route through confirmDestructive when the operation is destructive
     // enough to warrant a prompt (more than one rename) or when the user asked

package/dist/src/commands/furnace/rename-registrations.js

@@ -10,9 +10,11 @@ import { join } from 'node:path';
 import { loadConfig } from '../../core/config.js';
 import { resolveFtlChromeSubPath, resolveFtlLocaleJarMnPath, } from '../../core/furnace-constants.js';
 import { resolveFurnaceMarkerComment } from '../../core/furnace-marker.js';
-import { addCustomElementRegistration, addJarMnEntries, addLocaleFtlJarMnEntry, removeCustomElementRegistration, removeJarMnEntries, removeLocaleFtlJarMnEntry, renameCustomElementRegistration, } from '../../core/furnace-registration.js';
+import { addCustomElementRegistration, addJarMnEntries, addLocaleFtlJarMnEntry, removeCustomElementRegistration, removeLocaleFtlJarMnEntry, renameCustomElementRegistration, } from '../../core/furnace-registration.js';
+import { renameJarMnEntriesInPlace } from '../../core/furnace-registration-jar-inplace.js';
 import { snapshotFile } from '../../core/furnace-rollback.js';
 import { pathExists, readText, removeFile, writeText } from '../../utils/fs.js';
+import { renameComponentFileName } from './rename-helpers.js';
 /**
  * The project marker (`// <MARKER>:`) a registration line written by the
  * rename carries, resolved exactly as `furnace apply` resolves it. An
@@ -50,10 +52,13 @@ export async function updateEngineRegistrations(options) {
     }
     if (await pathExists(jarMnPath)) {
         await snapshotFile(journal, jarMnPath);
-        await removeJarMnEntries(engineDir, oldName);
         const files = (await readdir(newDir, { withFileTypes: true }))
             .filter((e) => e.isFile() && (e.name.endsWith('.mjs') || e.name.endsWith('.css')))
             .map((e) => e.name);
+        // Rewrite the old lines where they stand, like the customElements.js
+        // entry above, so the rename moves no other line of the block; only a
+        // file with no line yet is inserted.
+        await renameJarMnEntriesInPlace(engineDir, oldName, newName, files, (file) => renameComponentFileName(file, oldName, newName));
         if (files.length > 0) {
             await addJarMnEntries(engineDir, newName, files);
         }

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

@@ -7,6 +7,7 @@ import { assertFurnaceReady } from '../../core/furnace-precondition.js';
 import { addCustomElementRegistration, addJarMnEntries, pruneStaleJarMnEntries, } from '../../core/furnace-registration.js';
 import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
 import { applyValidationExceptions, } from '../../core/furnace-validate-exceptions.js';
+import { createIssue } from '../../core/furnace-validate-helpers.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
@@ -189,6 +190,20 @@ async function applyAutoFix(projectRoot, config, furnacePaths, run, countedIssue
 function exceptRun(run, config) {
     return applyValidationExceptions([...run.results.values()].flat(), config.validationExceptions, run.judged);
 }
+/**
+ * The `furnace.json#minComponents` floor of a full run: an error when it
+ * judged fewer components, so a run over an emptied or moved components
+ * tree cannot pass by validating nothing. A run naming one component is
+ * not judged against it.
+ */
+function componentFloorIssue(config, name, judged) {
+    if (name !== undefined || config.minComponents === undefined)
+        return undefined;
+    if (judged >= config.minComponents)
+        return undefined;
+    return createIssue('furnace.json', 'error', 'component-floor', `Validated ${judged} component(s), under furnace.json minComponents ${config.minComponents}. ` +
+        'Check that the components tree is where furnace.json says, or lower the floor.');
+}
 /**
  * Runs the furnace validate command to perform static analysis on components.
  * @param projectRoot - Root directory of the project
@@ -216,22 +231,32 @@ async function runFurnaceValidate(projectRoot, name, options) {
     const furnacePaths = getFurnacePaths(projectRoot);
     const run = await runValidationPass(projectRoot, name, config, furnacePaths);
     if (run === undefined) {
+        const floor = componentFloorIssue(config, name, 0);
         if (options.json === true) {
             renderValidateJson({
                 components: [],
-                outcome: { issues: [], excepted: [], stale: [] },
+                outcome: { issues: floor ? [floor] : [], excepted: [], stale: [] },
                 maxWarnings: options.maxWarnings,
             });
         }
+        if (floor !== undefined) {
+            renderValidateHuman([], [floor]);
+            throw new FurnaceError('Validation failed with 1 error(s).');
+        }
         outro(name ? 'Validation complete' : 'Done');
         return;
     }
+    const floor = componentFloorIssue(config, name, run.results.size);
     const firstPass = exceptRun(run, config);
+    if (floor !== undefined)
+        firstPass.issues.push(floor);
     renderValidateHuman([...run.results.keys()], firstPass.issues);
     let outcome = firstPass;
     if (options.fix && firstPass.issues.length > 0) {
         await applyAutoFix(projectRoot, config, furnacePaths, run, firstPass.issues);
         outcome = exceptRun(run, config);
+        if (floor !== undefined)
+            outcome.issues.push(floor);
     }
     const report = {
         components: [...run.results.keys()],

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

@@ -205,7 +205,8 @@ async function applyPerPatchResults(subset, results, issues, checkJs, cache, hel
                 heldNotices.push({ check: suppressedIssue.check, patch: patch.filename, suppressed: true });
                 continue;
             }
-            const ceiling = patch.lintIgnore?.find((entry) => isLintIgnoreCeiling(entry) && entry.rule === suppressedIssue.check);
+            const ceilings = (patch.lintIgnore ?? []).filter((entry) => isLintIgnoreCeiling(entry) && entry.rule === suppressedIssue.check);
+            const ceiling = ceilings.find((entry) => isLintIgnoreCeiling(entry) && entry.share === suppressedIssue.share) ?? ceilings[0];
             const waiver = ceiling === undefined ? 'lintIgnore' : `lintIgnore (${formatLintIgnoreEntry(ceiling)})`;
             info(`NOTICE [${suppressedIssue.check}] ${patch.filename}: suppressed by ${waiver} — ${suppressedIssue.message}`);
         }
@@ -404,7 +405,10 @@ async function lintPerPatchInner(projectRoot, paths, options = {}) {
     const { linted, skipped, cacheDirty, reusedCacheEntries, suppressed } = await applyPerPatchResults(subset, results, issues, checkJs, cache, heldNotices);
     const queueIssues = [];
     for (const issue of lintPatchQueue(ctx)) {
-        if (isSubset && !subsetTouchedFiles.has(issue.file))
+        // A finding that names a subset patch stays in scope even when its file
+        // is one the patch no longer touches (a stale staged declaration).
+        const namesSubset = issue.patches?.some((name) => subsetNames.has(name)) === true;
+        if (isSubset && !namesSubset && !subsetTouchedFiles.has(issue.file))
             continue;
         issues.push(issue);
         queueIssues.push(issue);

package/dist/src/commands/lint-per-run-checkjs.js

@@ -21,7 +21,7 @@
  *   cold" via `probeCheckJsGlobalIssues` instead of building anything.
  */
 import { invokePatchLintCheckJsGrouped, probeCheckJsGlobalIssues, runCheckJsTestFilesGrouped, } from '../core/patch-lint-checkjs.js';
-import { isTestScriptFile, resolvePatchOwnedSysMjs, resolvePatchOwnedTestScripts, } from '../core/patch-lint-ownership.js';
+import { isTestScriptFile, resolvableModulesForTests, resolvePatchOwnedSysMjs, resolvePatchOwnedTestScripts, } from '../core/patch-lint-ownership.js';
 /**
  * Builds the per-run checkJs program controller when `patchLint.checkJs` is
  * enabled, or returns undefined. With `rootScopePatches` set (the
@@ -69,7 +69,7 @@ export function buildPerRunCheckJs(projectRoot, paths, config, ctx, rootScopePat
         const sys = await invokePatchLintCheckJsGrouped(paths.engine, resolvePatchOwnedSysMjs(new Set(), ctx), patchLint, projectRoot, scopedRoots);
         if (!testFilesEnabled)
             return sys;
-        const tests = await runCheckJsTestFilesGrouped(paths.engine, resolvePatchOwnedTestScripts(new Set(), ctx), patchLint, projectRoot, scopedRoots);
+        const tests = await runCheckJsTestFilesGrouped(paths.engine, resolvePatchOwnedTestScripts(new Set(), ctx), patchLint, projectRoot, scopedRoots, resolvableModulesForTests(ctx));
         const byFile = new Map(sys.byFile);
         for (const [rel, list] of tests.byFile) {
             byFile.set(rel, [...(byFile.get(rel) ?? []), ...list]);

package/dist/src/commands/lint-report.js

@@ -10,7 +10,7 @@
  * none is wanted.
  */
 import { getPatchSizeThresholds, resolvePatchSizeTier, } from '../core/patch-lint.js';
-import { evaluateLintIgnoreCeilings, } from '../core/patch-lint-ignore.js';
+import { evaluateLintIgnoreCeilings, evaluateLintIgnoreWaivers, } from '../core/patch-lint-ignore.js';
 import { writeJson } from '../utils/fs.js';
 import { info } from '../utils/logger.js';
 const LINT_REPORT_SCHEMA_VERSION = 1;
@@ -37,6 +37,8 @@ export async function writePerPatchLintReport(reportPath, subset, results, confi
         if (!patch || !result)
             continue;
         const tier = resolvePatchSizeTier(result.existingFiles, patch.tier);
+        const findings = [...result.rawIssues, ...result.suppressedIssues];
+        const measurements = { lines: result.lineCount, files: patch.filesAffected.length };
         patches.push({
             filename: patch.filename,
             name: patch.name,
@@ -50,7 +52,10 @@ export async function writePerPatchLintReport(reportPath, subset, results, confi
             suppressedIssues: result.suppressedIssues,
             lintIgnoreCeilings: result.status === 'skipped'
                 ? []
-                : evaluateLintIgnoreCeilings(patch.lintIgnore, [...result.rawIssues, ...result.suppressedIssues], { lines: result.lineCount, files: patch.filesAffected.length }),
+                : evaluateLintIgnoreCeilings(patch.lintIgnore, findings, measurements),
+            lintIgnoreWaivers: result.status === 'skipped'
+                ? []
+                : evaluateLintIgnoreWaivers(patch.lintIgnore, findings, measurements),
         });
         if (result.status === 'skipped')
             skipped++;

package/dist/src/commands/manifest.js

@@ -11,6 +11,7 @@ import { registerFurnace } from './furnace/index.js';
 import { registerImport } from './import.js';
 import { registerLint } from './lint.js';
 import { registerPackage } from './package.js';
+import { registerPark } from './park.js';
 import { registerPatch } from './patch/index.js';
 import { registerReExport } from './re-export-register.js';
 import { registerRebase } from './rebase/index.js';
@@ -47,6 +48,7 @@ export const COMMAND_MANIFEST = [
     { name: 'export', group: 'workflow', register: registerExport },
     { name: 'export-all', group: 'workflow', register: registerExportAll },
     { name: 're-export', group: 'workflow', register: registerReExport },
+    { name: 'park', group: 'workflow', register: registerPark },
     { name: 'patch', group: 'workflow', register: registerPatch },
     { name: 'rebase', group: 'workflow', register: registerRebase },
     { name: 'package', group: 'workflow', register: registerPackage },