@hominis/fireforge 0.51.0 → 0.52.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.52.0
+
+### Test harness
+
+- `test --jobs` gives each harness instance its own mochitest test list (`--testrun-manifest-file`). On the shared default `tests.json` the second instance ran the first shard's file and the verdict passed, or it found no file at all. A `--jobs` run now always reads each dispatch's mozlog raw log, and a dispatch whose raw log starts none of its requested files fails with `started=0/<m>` instead of passing on another shard's results.
+- A negative control on compiled source escalates its pre-test build to a full `mach build`, with a notice that names the control's files. `mach build faster` compiles nothing, so under `--build` such a control still tested the previous binary and reported `control=missed`.
+- A `coverage-replaced` refusal names who wrote the coverage record: its invocation, when, and the writing process's pid (marked `still running` while it is), `FIREFORGE_SESSION_ID` and invocation id. Every build baseline now records that `recorder`, and `status --test-coverage` shows it.
+
+### Furnace
+
+- A `validationExceptions` entry can name a `file` of the component, as one can name a `tag`. `hardcoded-text` judges each module on its own and lists the modules in `files`, so a vendored bundle whose bytes are pinned can be accepted while the authored modules beside it keep the check. A `furnace-ignore: hardcoded-text` comment now covers only the file it is in.
+
+### Typecheck
+
+- `typecheck.litTypes` declares the global type `MozLitElementWith<Extra>`. A widget casts its `MozLitElement` base to it to type query getters and members declared only in `static properties`. Without `litTypes`, and under per-patch checkJs, the type is `any`, so the same source checks in both.
+
+### Other
+
+- CI: `github/codeql-action` 4.39.0.
+
 ## 0.51.0
 
 ### Test harness

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "version": "0.51.0",
-  "commit": "bd93338b037832fdcd69259a70a3a4b134b98906",
-  "shortCommit": "bd93338b0378",
+  "version": "0.52.0",
+  "commit": "8926d4e4fe3a6ce4c52f3cf1530776d09352b130",
+  "shortCommit": "8926d4e4fe3a",
   "dirty": false,
   "dirtyHash": null,
-  "buildTime": "2026-10-19T12:33:48.474Z"
+  "buildTime": "2026-10-19T23:32:47.811Z"
 }

package/dist/src/commands/status-output.js

@@ -206,7 +206,11 @@ export function renderTestCoverageStatus(baseline) {
     }
     info(`Last build: ${baseline.builtAt}  (binary: ${baseline.binaryName}, ` +
         `engine HEAD: ${baseline.engineHeadSha || '(unborn)'})`);
-    info(`Recorded by: ${baseline.recordedBy ?? 'unknown'}`);
+    const recorder = baseline.recorder;
+    info(`Recorded by: ${baseline.recordedBy ?? 'unknown'}` +
+        (recorder === undefined
+            ? ''
+            : ` (pid ${recorder.pid}${recorder.sessionId !== undefined ? `, session ${recorder.sessionId}` : ''})`));
     const coverage = baseline.testPackagingCoverage;
     if (coverage === undefined) {
         info('Test packaging coverage: full (implicit — baseline predates coverage recording)');

package/dist/src/commands/test-build-phase.d.ts

@@ -16,4 +16,6 @@ import type { HarnessClassification } from './test-modes.js';
 export declare function runTestBuildPhase(projectRoot: string, paths: ProjectPaths, projectConfig: FireForgeConfig, harnessRetries: number, options: TestOptions, request: {
     classification: HarnessClassification;
     normalizedPaths: string[];
+    /** Forces a full pre-test build (a compiled negative control). */
+    fullBuildReason?: string;
 }): Promise<boolean>;

package/dist/src/commands/test-build-phase.js

@@ -27,7 +27,7 @@ import { emitPassVerdict } from './test-verdict.js';
  * @param options - See {@link RunPreTestBuildOptions}
  */
 async function runPreTestBuild(options) {
-    const { projectRoot, paths, projectConfig, harnessRetries, testPackagingCoverage, refuseUnexportedDrift, extend, furnace, } = options;
+    const { projectRoot, paths, projectConfig, harnessRetries, testPackagingCoverage, refuseUnexportedDrift, extend, furnace, fullBuildReason, } = options;
     await withBuildLock(projectRoot, async () => {
         // Pass the previous baseline exactly like `fireforge build` does, so
         // auto-configure runs under the same conditions on both paths. The
@@ -66,17 +66,16 @@ async function runPreTestBuild(options) {
             if (retentionNotice !== undefined)
                 notice(retentionNotice);
         }
-        const buildKind = preparation.fullBuildRequired ? 'full' : 'faster';
-        if (preparation.fullBuildRequired) {
+        const fullBuild = preparation.fullBuildRequired || fullBuildReason !== undefined;
+        const buildKind = fullBuild ? 'full' : 'faster';
+        if (fullBuild) {
             // Warning severity rather than info: agent-facing output filters
             // keep warnings and errors only, and this is the line that explains an
             // otherwise unexplained multi-minute build.
-            notice(preparation.fullBuildReason ??
+            notice((preparation.fullBuildRequired ? preparation.fullBuildReason : fullBuildReason) ??
                 'A jar.mn registration changed since the last successful build; escalating this pre-test build to a full mach build so new install-manifest destinations are created.');
         }
-        const s = spinner(preparation.fullBuildRequired
-            ? 'Running required full build...'
-            : 'Running incremental build...');
+        const s = spinner(fullBuild ? 'Running required full build...' : 'Running incremental build...');
         // The pre-test build routes through the same protected mach dispatch as
         // `fireforge build` / `build --ui`: in-venv resource-monitor guard plus
         // the uniform recognized-crash retry budget, with a fresh mach process
@@ -116,7 +115,7 @@ async function runPreTestBuild(options) {
                     ...recorded,
                     previousBaseline,
                     recordedBy: describeBuildInvocation(extend !== undefined, testPackagingCoverage),
-                    staticComponentsHandling: preparation.fullBuildRequired
+                    staticComponentsHandling: fullBuild
                         ? 'refresh'
                         : plan !== undefined && (plan.keepFull || Object.keys(plan.retained).length > 0)
                             ? 'carry-forward'
@@ -131,8 +130,8 @@ async function runPreTestBuild(options) {
         }
         s.error('Pre-test build failed');
         throw new BuildError(result.crashSignature
-            ? buildHarnessCrashMessage(result.crashSignature, result.attempts, 'mach build faster')
-            : 'Pre-test build failed', preparation.fullBuildRequired ? 'mach build' : 'mach build faster');
+            ? buildHarnessCrashMessage(result.crashSignature, result.attempts, fullBuild ? 'mach build' : 'mach build faster')
+            : 'Pre-test build failed', fullBuild ? 'mach build' : 'mach build faster');
     });
 }
 /**
@@ -201,7 +200,7 @@ function describeBuildInvocation(extending, coverage) {
  * next steps, and emits the run's single `PASS` verdict.
  */
 export async function runTestBuildPhase(projectRoot, paths, projectConfig, harnessRetries, options, request) {
-    const { classification, normalizedPaths } = request;
+    const { classification, normalizedPaths, fullBuildReason } = request;
     const extending = options.extendCoverage === true;
     if (extending) {
         assertExtendCoverageUsage(options, normalizedPaths);
@@ -235,6 +234,7 @@ export async function runTestBuildPhase(projectRoot, paths, projectConfig, harne
             testPackagingCoverage: coverage,
             refuseUnexportedDrift: options.refuseUnexportedDrift === true,
             extend: extending ? { requestedPaths: normalizedPaths } : undefined,
+            fullBuildReason,
             furnace: await planPreTestFurnace(projectRoot, paths, projectConfig, options, normalizedPaths),
         });
         info('');

package/dist/src/commands/test-dispatch.js

@@ -85,25 +85,34 @@ async function allocateLoopbackPort() {
         });
     });
 }
+/**
+ * The mochitest harness writes the dispatched test list to
+ * `_tests/testing/mochitest/tests.json` and the browser fetches it from
+ * there, so instances sharing the default name read each other's list (and
+ * one instance's cleanup removes it under the other). Each instance names
+ * its own file.
+ */
+function testRunManifestArg(index) {
+    return `--testrun-manifest-file=fireforge-tests-${process.pid}-job${index + 1}.json`;
+}
 /**
  * The context for `--jobs` instance `index` (0-based): its own output
- * prefix, and from the second instance on its own Marionette port, so
- * browsers started at the same moment never race for 2828. The mochitest
- * server ports are left to the engine harness's busy-port fallback, which
- * `--jobs` requires (auto ports).
+ * prefix and test-list manifest, and from the second instance on its own
+ * Marionette port, so browsers started at the same moment never race for
+ * 2828. The mochitest server ports are left to the engine harness's
+ * busy-port fallback, which `--jobs` requires (auto ports).
  */
 async function instanceContext(base, index, xpcshellOnly) {
     const ctx = { ...base, outputPrefix: `[job ${index + 1}] ` };
-    if (index === 0 || xpcshellOnly)
+    if (xpcshellOnly)
         return ctx;
+    const own = [...base.baseExtraArgs, testRunManifestArg(index)];
+    if (index === 0)
+        return { ...ctx, baseExtraArgs: own };
     const port = await allocateLoopbackPort();
     return {
         ...ctx,
-        baseExtraArgs: [
-            ...base.baseExtraArgs,
-            `--setpref=marionette.port=${port}`,
-            `--marionette=127.0.0.1:${port}`,
-        ],
+        baseExtraArgs: [...own, `--setpref=marionette.port=${port}`, `--marionette=127.0.0.1:${port}`],
     };
 }
 /** The shards to run, or undefined for one combined invocation. */

package/dist/src/commands/test-orchestrate.d.ts

@@ -30,6 +30,11 @@ export interface TestRunHooks {
      * source, which only reaches the binary when the build compiles it.
      */
     beforeBuild?: () => Promise<void>;
+    /**
+     * Why the pre-test build must be a full `mach build`: `mach build faster`
+     * compiles nothing, so a compiled control's binary needs the full one.
+     */
+    fullBuildReason?: string;
     /** `--repeat` run this sub-run is (1-based), for `--results`. */
     repetition?: number;
     /** Where dispatches write their mozlog raw logs (`--results`, `--shard-size`). */

package/dist/src/commands/test-orchestrate.js

@@ -17,7 +17,7 @@
  */
 import { getProjectPaths } from '../core/config.js';
 import { applyNegativeControl, planNegativeControl, recoverPendingNegativeControl, restoreNegativeControl, } from '../core/negative-control.js';
-import { formatCompiledControlRefusal } from '../core/negative-control-compiled.js';
+import { formatCompiledControlBuildNotice, formatCompiledControlRefusal, } from '../core/negative-control-compiled.js';
 import { getActiveRunLogPath, writeToActiveRunLog } from '../core/run-log.js';
 import { GeneralError, InvalidArgumentError, PreflightRefusalError } from '../errors/base.js';
 import { TestFailureError } from '../errors/build.js';
@@ -187,7 +187,10 @@ export async function orchestrateTestRuns(projectRoot, testPaths, options, body,
                 ...(plan === undefined
                     ? {}
                     : compiledControl && index === 0
-                        ? { beforeBuild: controlHook(controlPaths, plan, slot) }
+                        ? {
+                            beforeBuild: controlHook(controlPaths, plan, slot),
+                            fullBuildReason: formatCompiledControlBuildNotice(compiled),
+                        }
                         : { beforeDispatch: controlHook(controlPaths, plan, slot) }),
             });
         }

package/dist/src/commands/test-stale-gate.js

@@ -11,6 +11,7 @@ import { filterByCarriedFullCoverage } from '../core/coverage-dispatch.js';
 import { checkStaleBuildForTest, checkStaticComponentsStale, findChangedTestManifestsForPaths, findUncoveredRequestPaths, formatStaleBuildWarning, formatStaticComponentsRefusal, formatTestCoverageRefusal, FULL_SUITE_REQUEST, } from '../core/test-stale-check.js';
 import { formatStaleExemptions } from '../core/test-stale-exempt.js';
 import { PreflightRefusalError } from '../errors/base.js';
+import { isProcessAlive } from '../utils/errors.js';
 import { info, warn } from '../utils/logger.js';
 import { describePerfStaleImpact } from './test-perf-scope.js';
 /**
@@ -93,6 +94,12 @@ async function enforceCoverageGate(engineDir, baseline, normalizedPaths) {
     throw new PreflightRefusalError(formatTestCoverageRefusal(uncovered, Array.isArray(recordedCoverage) ? recordedCoverage : [], changedManifests, {
         changedInputs: Object.fromEntries(remaining.map((request) => [request.path, request.changed])),
         carriesFullAnchor: baseline?.fullCoverageAnchor !== undefined,
+        recordedBy: baseline?.recordedBy,
+        builtAt: baseline?.builtAt,
+        recorder: baseline?.recorder,
+        recorderAlive: baseline?.recorder !== undefined &&
+            baseline.recorder.pid !== process.pid &&
+            isProcessAlive(baseline.recorder.pid),
     }), 'coverage-replaced');
 }
 /**

package/dist/src/commands/test.js

@@ -142,7 +142,9 @@ export async function testCommand(projectRoot, testPaths, options = {}, underLoc
             renderPreflightRefusal(error);
             emitFailVerdict('preflight', refusalNote(error));
         });
-        const collectsResults = options.results !== undefined || options.shardSize !== undefined;
+        // `--jobs` always reads each dispatch's raw log, so a shard that ran
+        // files other than its own fails instead of passing on their results.
+        const collectsResults = options.results !== undefined || options.shardSize !== undefined || (options.jobs ?? 1) > 1;
         try {
             await underLock(() => (collectsResults ? withRawLogDir((dir) => orchestrate(dir)) : orchestrate()), lockMode);
         }
@@ -346,6 +348,7 @@ async function runTestCommandBody(projectRoot, testPaths, options = {}, profileE
     if (await runTestBuildPhase(projectRoot, paths, projectConfig, harnessRetries, options, {
         classification,
         normalizedPaths: hooks.coveragePaths ?? normalizedPaths,
+        ...(hooks.fullBuildReason === undefined ? {} : { fullBuildReason: hooks.fullBuildReason }),
     })) {
         return;
     }

package/dist/src/core/build-baseline-types.d.ts

@@ -144,6 +144,19 @@ export interface BuildBaseline {
      * as "unknown" when absent.
      */
     recordedBy?: string;
+    /**
+     * The process that wrote this baseline: its pid, its invocation id (the
+     * one its history records carry) and the caller's `FIREFORGE_SESSION_ID`
+     * when set. A coverage refusal names it, so a run whose claim another
+     * session's scoped build replaced can tell whose build that was.
+     */
+    recorder?: BaselineRecorder;
+}
+/** See {@link BuildBaseline.recorder}. */
+export interface BaselineRecorder {
+    pid: number;
+    invocationId: string;
+    sessionId?: string;
 }
 /**
  * State of the engine at the last full build, as far as compiled-in XPCOM

package/dist/src/core/build-baseline-validate.js

@@ -32,6 +32,13 @@ function isCoverageRecordMap(value) {
             Array.isArray(record['inputs']) &&
             record['inputs'].every(isBaselinePath)));
 }
+/** A `recorder` stamp: an integer pid, an invocation id and an optional session id. */
+function isBaselineRecorder(value) {
+    return (isObject(value) &&
+        Number.isInteger(value['pid']) &&
+        typeof value['invocationId'] === 'string' &&
+        (value['sessionId'] === undefined || typeof value['sessionId'] === 'string'));
+}
 /** Validates persisted fields without converting malformed coverage into a full claim. */
 export function isBuildBaseline(value) {
     if (!isObject(value))
@@ -59,6 +66,8 @@ export function isBuildBaseline(value) {
         return false;
     if (value['recordedBy'] !== undefined && typeof value['recordedBy'] !== 'string')
         return false;
+    if (value['recorder'] !== undefined && !isBaselineRecorder(value['recorder']))
+        return false;
     if (value['testCoverageRecords'] !== undefined &&
         !isCoverageRecordMap(value['testCoverageRecords']))
         return false;

package/dist/src/core/build-baseline.js

@@ -32,6 +32,7 @@ import { hashEngineFile } from './coverage-extend.js';
 import { getHead, hasChanges, isMissingHeadError } from './git.js';
 import { git } from './git-base.js';
 import { getUntrackedFiles } from './git-status.js';
+import { historyRecordIdentity } from './history-log-file.js';
 /*
  * Keep the IO fan-out bounded: a patched Firefox checkout can carry hundreds
  * of dirty packageable paths and serial reads add directly to every build.
@@ -72,6 +73,11 @@ export async function readBuildBaseline(projectRoot, invalid = 'ignore') {
         return undefined;
     }
 }
+/** This process's {@link BuildBaseline.recorder} stamp. */
+function baselineRecorder() {
+    const { pid, invocationId, sessionId } = historyRecordIdentity();
+    return { pid, invocationId, ...(sessionId !== undefined ? { sessionId } : {}) };
+}
 /**
  * Records a successful build by writing a fresh baseline marker. Captures
  * engine HEAD SHA (or an empty string when the engine has no HEAD yet) and
@@ -121,6 +127,7 @@ export async function writeBuildBaseline(options) {
         ...(mozconfigHash !== undefined ? { mozconfigHash } : {}),
         ...(staticComponentsBaseline !== undefined ? { staticComponentsBaseline } : {}),
         ...(recordedBy !== undefined ? { recordedBy } : {}),
+        recorder: baselineRecorder(),
     };
     await writeJson(getBuildBaselinePath(projectRoot), baseline);
 }

package/dist/src/core/furnace-config-validate-exceptions.d.ts

@@ -1,8 +1,9 @@
 import { type FurnaceOptInCheck, type FurnaceValidationException } from '../types/furnace.js';
 /**
- * Parses `validationExceptions[]`: `{ component, check, tag?, reason }`
- * objects, no other keys, every field a non-empty string, and no two
- * entries for the same component, check and tag.
+ * Parses `validationExceptions[]`: `{ component, check, tag?, file?, reason }`
+ * objects, no other keys, every field a non-empty string, at most one of
+ * `tag` and `file` (a bare file name of the component), and no two entries
+ * for the same component, check and scope.
  */
 export declare function parseValidationExceptions(raw: unknown): FurnaceValidationException[];
 /**

package/dist/src/core/furnace-config-validate-exceptions.js

@@ -11,7 +11,7 @@
 import { FurnaceError } from '../errors/furnace.js';
 import { FURNACE_OPT_IN_CHECKS, } from '../types/furnace.js';
 import { isArray, isObject, isString } from '../utils/validation.js';
-const EXCEPTION_KEYS = new Set(['component', 'check', 'tag', 'reason']);
+const EXCEPTION_KEYS = new Set(['component', 'check', 'tag', 'file', 'reason']);
 function requireNonEmptyString(entry, key, field) {
     const value = entry[key];
     if (!isString(value) || value.trim().length === 0) {
@@ -20,9 +20,10 @@ function requireNonEmptyString(entry, key, field) {
     return value;
 }
 /**
- * Parses `validationExceptions[]`: `{ component, check, tag?, reason }`
- * objects, no other keys, every field a non-empty string, and no two
- * entries for the same component, check and tag.
+ * Parses `validationExceptions[]`: `{ component, check, tag?, file?, reason }`
+ * objects, no other keys, every field a non-empty string, at most one of
+ * `tag` and `file` (a bare file name of the component), and no two entries
+ * for the same component, check and scope.
  */
 export function parseValidationExceptions(raw) {
     if (!isArray(raw)) {
@@ -46,9 +47,28 @@ export function parseValidationExceptions(raw) {
         };
         if (entry['tag'] !== undefined)
             exception.tag = requireNonEmptyString(entry, 'tag', field);
-        const identity = `${exception.component}\u0000${exception.check}\u0000${exception.tag ?? ''}`;
+        if (entry['file'] !== undefined) {
+            if (exception.tag !== undefined) {
+                throw new FurnaceError(`Furnace config: "${field}" may name a "tag" or a "file", not both`);
+            }
+            const file = requireNonEmptyString(entry, 'file', field);
+            if (/[\\/]/.test(file) || file === '.' || file === '..') {
+                throw new FurnaceError(`Furnace config: "${field}.file" must be a file name in the component's directory, not a path`);
+            }
+            exception.file = file;
+        }
+        const scope = exception.tag !== undefined
+            ? `tag:${exception.tag}`
+            : exception.file !== undefined
+                ? `file:${exception.file}`
+                : '';
+        const identity = `${exception.component}\u0000${exception.check}\u0000${scope}`;
         if (seen.has(identity)) {
-            const on = exception.tag !== undefined ? ` on <${exception.tag}>` : '';
+            const on = exception.tag !== undefined
+                ? ` on <${exception.tag}>`
+                : exception.file !== undefined
+                    ? ` in ${exception.file}`
+                    : '';
             throw new FurnaceError(`Furnace config: "${field}" repeats the exception for ${exception.component} [${exception.check}]${on}`);
         }
         seen.add(identity);

package/dist/src/core/furnace-validate-accessibility.d.ts

@@ -34,6 +34,6 @@ export declare function validateAccessibility(componentDir: string, tagName: str
  *      `title=`, or `tooltiptext=` attribute when constructing DOM in JS.
  *
  * A file-wide `// furnace-ignore: hardcoded-text` comment suppresses all
- * findings (matches the pre-existing escape hatch).
+ * findings in that file (matches the pre-existing escape hatch).
  */
 export declare function containsHardcodedTemplateText(content: string): boolean;

package/dist/src/core/furnace-validate-accessibility.js

@@ -11,8 +11,9 @@ import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-templa
  * findings do not depend on which of the component's modules it lives in.
  * Returns undefined when the host module is missing.
  */
-async function readComposedComponentSource(componentDir, tagName) {
-    const hostPath = join(componentDir, `${tagName}.mjs`);
+async function readComposedComponentModules(componentDir, tagName) {
+    const hostName = `${tagName}.mjs`;
+    const hostPath = join(componentDir, hostName);
     if (!(await pathExists(hostPath)))
         return undefined;
     const entries = await readdir(componentDir).catch(() => []);
@@ -21,10 +22,11 @@ async function readComposedComponentSource(componentDir, tagName) {
         name.endsWith('.mjs') &&
         !/\.(test|spec|stories)\./.test(name))
         .sort();
-    const sources = [await readText(hostPath)];
-    for (const name of companions)
-        sources.push(await readText(join(componentDir, name)));
-    return sources.join('\n');
+    const modules = [{ name: hostName, content: await readText(hostPath) }];
+    for (const name of companions) {
+        modules.push({ name, content: await readText(join(componentDir, name)) });
+    }
+    return modules;
 }
 /**
  * Validates accessibility patterns in a component's composed source: its
@@ -44,9 +46,10 @@ async function readComposedComponentSource(componentDir, tagName) {
  *   adds the icon-only `<moz-button>` naming check.
  */
 export async function validateAccessibility(componentDir, tagName, customConfig, optInChecks = []) {
-    const content = await readComposedComponentSource(componentDir, tagName);
-    if (content === undefined)
+    const modules = await readComposedComponentModules(componentDir, tagName);
+    if (modules === undefined)
         return [];
+    const content = modules.map((module) => module.content).join('\n');
     const issues = [];
     if (!hasAriaRole(content) && hasGenericInteractiveElement(content)) {
         issues.push(createIssue(tagName, 'warning', 'no-aria-role', 'Generic interactive markup has no native semantics. Prefer native elements, or add role= when native markup cannot provide the semantics.'));
@@ -72,8 +75,16 @@ export async function validateAccessibility(componentDir, tagName, customConfig,
             tags: syntheticTags,
         });
     }
-    if (containsHardcodedTemplateText(content)) {
-        issues.push(createIssue(tagName, 'warning', 'hardcoded-text', 'Possible hardcoded string found. Use data-l10n-id for localization.'));
+    // Judged per module, so the finding names its files and an exception can
+    // accept one module (a vendored bundle) without muting the others.
+    const textFiles = modules
+        .filter((module) => containsHardcodedTemplateText(module.content))
+        .map((module) => module.name);
+    if (textFiles.length > 0) {
+        issues.push({
+            ...createIssue(tagName, 'warning', 'hardcoded-text', `Possible hardcoded string found in ${textFiles.join(', ')}. Use data-l10n-id for localization.`),
+            files: textFiles,
+        });
     }
     const isInteractive = hasClick || hasKeyboardHandler;
     if (isInteractive && !hasDelegatesFocusEnabled(content)) {
@@ -337,7 +348,7 @@ function isWithinLocalizedElement(content, matchIndex) {
  *      `title=`, or `tooltiptext=` attribute when constructing DOM in JS.
  *
  * A file-wide `// furnace-ignore: hardcoded-text` comment suppresses all
- * findings (matches the pre-existing escape hatch).
+ * findings in that file (matches the pre-existing escape hatch).
  */
 export function containsHardcodedTemplateText(content) {
     if (/furnace-ignore:\s*hardcoded-text/.test(content)) {

package/dist/src/core/furnace-validate-exceptions.d.ts

@@ -2,7 +2,8 @@
  * Applies `furnace.json#validationExceptions[]` to a `furnace validate`
  * result. An exception suppresses every finding of its check on its
  * component, or with `tag`, a finding whose element tags it (and its
- * sibling tag entries) cover. One that suppresses nothing is stale: the
+ * sibling tag entries) cover, or with `file`, a finding whose module files
+ * it (and its sibling file entries) cover. One that suppresses nothing is stale: the
  * finding was fixed (or renamed) and the review record outlived it, so it
  * is reported as a warning naming the entry to delete, which keeps the
  * list honest under `--max-warnings 0`.

package/dist/src/core/furnace-validate-exceptions.js

@@ -6,19 +6,34 @@ export const EXCEPTION_ON_ERROR_CHECK = 'validation-exception-on-error';
 function matches(exception, issue) {
     return exception.component === issue.component && exception.check === issue.check;
 }
+/** An exception's narrowing: the finding field it reads and its value. */
+function scopeOf(entry) {
+    if (entry.tag !== undefined)
+        return { key: 'tags', value: entry.tag };
+    if (entry.file !== undefined)
+        return { key: 'files', value: entry.file };
+    return undefined;
+}
 /**
- * The exceptions that suppress a warning: an untagged one alone, or tagged
- * ones that together cover every tag the finding names.
+ * The exceptions that suppress a warning: an unscoped one alone, or scoped
+ * ones that together cover every tag (or every file) the finding names.
  */
 function coveringExceptions(issue, candidates) {
-    const untagged = candidates.find((entry) => entry.tag === undefined);
-    if (untagged !== undefined)
-        return [untagged];
-    const tags = issue.tags ?? [];
-    if (tags.length === 0)
-        return [];
-    const covering = tags.map((tag) => candidates.find((entry) => entry.tag === tag));
-    return covering.every((entry) => entry !== undefined) ? [...new Set(covering)] : [];
+    const unscoped = candidates.find((entry) => scopeOf(entry) === undefined);
+    if (unscoped !== undefined)
+        return [unscoped];
+    for (const key of ['tags', 'files']) {
+        const named = issue[key] ?? [];
+        if (named.length === 0)
+            continue;
+        const covering = named.map((value) => candidates.find((entry) => {
+            const scope = scopeOf(entry);
+            return scope?.key === key && scope.value === value;
+        }));
+        if (covering.every((entry) => entry !== undefined))
+            return [...new Set(covering)];
+    }
+    return [];
 }
 /**
  * Splits findings into counted and excepted, and reports stale exceptions.
@@ -47,11 +62,14 @@ export function applyValidationExceptions(issues, exceptions, judged) {
         }
         const covering = coveringExceptions(issue, candidates);
         if (covering.length === 0) {
-            // A tagged exception that covers some of the tags is not stale: its
-            // element still carries the finding, beside one it does not cover.
+            // A scoped exception that covers some of the tags (or files) is not
+            // stale: its element still carries the finding, beside one it does
+            // not cover.
             for (const entry of candidates) {
-                if (entry.tag !== undefined && issue.tags?.includes(entry.tag) === true)
+                const scope = scopeOf(entry);
+                if (scope !== undefined && issue[scope.key]?.includes(scope.value) === true) {
                     used.add(entry);
+                }
             }
             outcome.issues.push(issue);
             continue;

package/dist/src/core/negative-control-compiled.d.ts

@@ -7,7 +7,9 @@
  * never compiled: the run tests the unmutated binary and reports
  * `control=missed`, which reads as a test that cannot fail. Such a target
  * is now refused without `--build`, and with `--build` the control is
- * applied before the build so the binary under test carries it.
+ * applied before the build so the binary under test carries it. That build
+ * is a full `mach build`: the pre-test build is otherwise `mach build
+ * faster`, which compiles nothing, so the control still missed.
  */
 /**
  * The engine-relative targets that reach the runtime only through a
@@ -18,6 +20,13 @@
  * @param enginePaths - The control's engine-relative targets
  */
 export declare function findCompiledControlTargets(engineDir: string, enginePaths: readonly string[]): Promise<string[]>;
+/**
+ * The notice that explains why a compiled control's pre-test build is a
+ * full `mach build` instead of `mach build faster`.
+ *
+ * @param compiled - Engine-relative compiled targets
+ */
+export declare function formatCompiledControlBuildNotice(compiled: readonly string[]): string;
 /**
  * The refusal for a compiled control without `--build`, naming the manual
  * procedure for a run that wants to keep its build out of FireForge.

package/dist/src/core/negative-control-compiled.js

@@ -8,7 +8,9 @@
  * never compiled: the run tests the unmutated binary and reports
  * `control=missed`, which reads as a test that cannot fail. Such a target
  * is now refused without `--build`, and with `--build` the control is
- * applied before the build so the binary under test carries it.
+ * applied before the build so the binary under test carries it. That build
+ * is a full `mach build`: the pre-test build is otherwise `mach build
+ * faster`, which compiles nothing, so the control still missed.
  */
 import { extname } from 'node:path';
 import { classifyRuntimeDelivery } from './objdir-install-manifests.js';
@@ -55,6 +57,18 @@ export async function findCompiledControlTargets(engineDir, enginePaths) {
     }
     return compiled;
 }
+/**
+ * The notice that explains why a compiled control's pre-test build is a
+ * full `mach build` instead of `mach build faster`.
+ *
+ * @param compiled - Engine-relative compiled targets
+ */
+export function formatCompiledControlBuildNotice(compiled) {
+    const files = compiled.map((path) => `engine/${path}`).join(', ');
+    return (`The negative control edits compiled source (${files}); escalating this pre-test build to ` +
+        'a full mach build, since mach build faster compiles nothing and the binary under test ' +
+        'would not carry the control.');
+}
 /**
  * The refusal for a compiled control without `--build`, naming the manual
  * procedure for a run that wants to keep its build out of FireForge.

package/dist/src/core/test-run-completeness.d.ts

@@ -17,10 +17,14 @@
  * `FAIL reason=test-failures`, and a short start count is stamped on the
  * verdict line as `started=<n>/<m> first-unstarted=<path>`.
  *
- * The start-count check only runs when at least one start marker names a
- * requested file. The suite-specific xpcshell dispatch can prove execution
- * with a result-summary block alone and print no `TEST_START` line, and a
- * run that never names its files cannot be counted against them.
+ * From streamed or captured text, the start-count check only runs when at
+ * least one start marker names a requested file. The suite-specific xpcshell
+ * dispatch can prove execution with a result-summary block alone and print
+ * no `TEST_START` line, and a run that never names its files cannot be
+ * counted against them. The structured raw log names every test by its
+ * manifest id, so a raw log whose starts name none of the requested files
+ * ran something else: a `--jobs` instance that read another instance's test
+ * list once passed on that instance's file.
  */
 import { type HarnessRunVerdict } from './test-harness-crash.js';
 import type { IncompleteRunEvidence } from './test-harness-signature.js';
@@ -62,8 +66,11 @@ export declare function createStartMarkerTracker(): StartMarkerTracker;
  * @param evidence - Captured mach stdout and stderr, or the markers
  *   collected from the complete stream
  * @param requestedPaths - Dispatched paths, in dispatch order
+ * @param authoritative - The markers come from the raw log, so a run whose
+ *   starts name no requested file is counted (as none started) instead of
+ *   being left uncounted
  */
-export declare function countStartedFiles(evidence: string | StartMarkers, requestedPaths: readonly string[]): {
+export declare function countStartedFiles(evidence: string | StartMarkers, requestedPaths: readonly string[], authoritative?: boolean): {
     started: number;
     requested: number;
     firstUnstarted?: string;

package/dist/src/core/test-run-completeness.js

@@ -18,10 +18,14 @@
  * `FAIL reason=test-failures`, and a short start count is stamped on the
  * verdict line as `started=<n>/<m> first-unstarted=<path>`.
  *
- * The start-count check only runs when at least one start marker names a
- * requested file. The suite-specific xpcshell dispatch can prove execution
- * with a result-summary block alone and print no `TEST_START` line, and a
- * run that never names its files cannot be counted against them.
+ * From streamed or captured text, the start-count check only runs when at
+ * least one start marker names a requested file. The suite-specific xpcshell
+ * dispatch can prove execution with a result-summary block alone and print
+ * no `TEST_START` line, and a run that never names its files cannot be
+ * counted against them. The structured raw log names every test by its
+ * manifest id, so a raw log whose starts name none of the requested files
+ * ran something else: a `--jobs` instance that read another instance's test
+ * list once passed on that instance's file.
  */
 import { SHUTDOWN_REENTRY_PATTERN, START_MARKER_PATTERN, TEST_FILE_BASENAME_PATTERN, } from './test-harness-crash.js';
 /**
@@ -80,8 +84,11 @@ export function createStartMarkerTracker() {
  * @param evidence - Captured mach stdout and stderr, or the markers
  *   collected from the complete stream
  * @param requestedPaths - Dispatched paths, in dispatch order
+ * @param authoritative - The markers come from the raw log, so a run whose
+ *   starts name no requested file is counted (as none started) instead of
+ *   being left uncounted
  */
-export function countStartedFiles(evidence, requestedPaths) {
+export function countStartedFiles(evidence, requestedPaths, authoritative = false) {
     const requested = requestedPaths.filter((path) => TEST_FILE_BASENAME_PATTERN.test(basenameOf(path)));
     if (requested.length === 0)
         return undefined;
@@ -92,8 +99,8 @@ export function countStartedFiles(evidence, requestedPaths) {
     };
     // Counting needs a dialect that names the requested files on its start
     // lines. When no start line names any of them, the output cannot be
-    // counted against the request at all.
-    if (!requested.some((path) => names(path, started)))
+    // counted against the request at all, unless it is the raw log.
+    if (!authoritative && !requested.some((path) => names(path, started)))
         return undefined;
     const unstarted = requested.filter((path) => !names(path, started) && !names(path, skipped));
     const firstUnstarted = unstarted[0];
@@ -125,7 +132,7 @@ export function vetoIncompletePass(verdict, output, requestedPaths, tracked) {
     // tracker means nothing was streamed through it, and the capture is then
     // the only evidence there is.
     const useTracked = tracked !== undefined && tracked.markers.started.length > 0;
-    const counted = countStartedFiles(useTracked ? tracked.markers : output, requestedPaths);
+    const counted = countStartedFiles(useTracked ? tracked.markers : output, requestedPaths, useTracked && tracked.source === 'raw');
     const unexpected = verdict.unexpected ?? 0;
     const truncated = counted?.firstUnstarted !== undefined;
     if (unexpected === 0 && shutdownLine === undefined && !truncated)

package/dist/src/core/test-stale-check.d.ts

@@ -1,4 +1,4 @@
-import type { BuildBaseline, TestPackagingCoverage } from './build-baseline-types.js';
+import type { BaselineRecorder, BuildBaseline, TestPackagingCoverage } from './build-baseline-types.js';
 import { type StaleExemption } from './test-stale-exempt.js';
 /** Result of the stale-build preflight probe. */
 export interface StaleBuildResult {
@@ -97,6 +97,15 @@ export interface CoverageRefusalDetail {
     changedInputs?: Readonly<Record<string, readonly string[]>>;
     /** The record carries a full build's anchor forward for unchanged paths. */
     carriesFullAnchor?: boolean;
+    /**
+     * Who wrote the record and when, so a run whose coverage a peer's scoped
+     * build replaced can tell whose build that was.
+     */
+    recordedBy?: string | undefined;
+    builtAt?: string | undefined;
+    recorder?: BaselineRecorder | undefined;
+    /** Whether the recorder's process is still running (it may still be using the packaging). */
+    recorderAlive?: boolean | undefined;
 }
 /**
  * Formats the refusal shown when a non-`--build` run requests paths the

package/dist/src/core/test-stale-check.js

@@ -163,6 +163,20 @@ export async function findChangedTestManifestsForPaths(engineDir, baseline, unco
     });
     return hits.slice(0, STALE_PATHS_LIMIT);
 }
+/** The refusal's sentence naming who wrote the coverage record. */
+function formatCoverageHolder(detail) {
+    if (detail.recorder === undefined && detail.recordedBy === undefined)
+        return '';
+    const what = detail.recordedBy !== undefined ? `"${detail.recordedBy}"` : 'a build';
+    const when = detail.builtAt !== undefined ? ` at ${detail.builtAt}` : '';
+    const recorder = detail.recorder;
+    const who = recorder === undefined
+        ? ''
+        : ` (pid ${recorder.pid}${detail.recorderAlive === true ? ', still running' : ''}` +
+            (recorder.sessionId !== undefined ? `, session ${recorder.sessionId}` : '') +
+            `, invocation ${recorder.invocationId})`;
+    return ` The current record was written by ${what}${when}${who}.`;
+}
 /**
  * Formats the refusal shown when a non-`--build` run requests paths the
  * packaged runtime's scoped `test --build` coverage does not include. It is
@@ -210,7 +224,7 @@ export function formatTestCoverageRefusal(uncovered, coverage, changedManifests
     return (`The packaged test runtime was produced by a scoped "fireforge test --build" covering only: ${scope}.\n` +
         `The requested run needs ${cap(uncovered)}, which that packaging does not cover — support ` +
         'fixtures for those manifests may be missing from obj-*/_tests/, and the run can hang ' +
-        `rather than fail.${affectedLine}${manifestLine} ${rebuildHint} ` +
+        `rather than fail.${formatCoverageHolder(detail)}${affectedLine}${manifestLine} ${rebuildHint} ` +
         '(--allow-stale-build does not bypass this check — it accepts stale content, not missing coverage.)');
 }
 /**

package/dist/src/core/typecheck-shim.d.ts

@@ -82,7 +82,8 @@ export interface ComposedShim {
  *   shim path
  * @param extraShimPath - Optional project-relative path to an extra `.d.ts`
  * @param options - `litTypes` appends {@link LIT_TYPES_SHIM} after the
- *   built-in shim (before the extra shim, which can still merge into it)
+ *   built-in shim (before the extra shim, which can still merge into it),
+ *   and {@link LOOSE_LIT_SHIM} otherwise
  */
 export declare function composeShimSource(projectRoot: string, extraShimPath: string | undefined, options?: {
     litTypes?: boolean | undefined;

package/dist/src/core/typecheck-shim.js

@@ -295,8 +295,13 @@ export const UNDEFINED_IDENTIFIER_CODES = new Set([
  * `chrome:*` wildcard as `any`: `LitElement` (with `ReactiveElement`'s
  * lifecycle) and `MozLitElement` carry closed member lists, so a misspelt
  * member of a widget host is TS2339, as `Cu` is in the built-in shim.
- * Template helpers and directives stay loose. A project shim can merge
- * members into `LitElementShimMembers`; a project whose jsconfig `paths`
+ * Template helpers and directives stay loose. The global
+ * `MozLitElementWith<Extra>` types a widget's query getters and
+ * `static properties` members: the widget casts its `MozLitElement` import
+ * to it before extending ({@link LOOSE_LIT_SHIM} keeps it `any` without
+ * typed Lit). A project
+ * shim can merge members into `LitElementShimMembers`; a project whose
+ * jsconfig `paths`
  * maps these URLs to the real sources gets those instead, since a resolved
  * file wins over an ambient module.
  */
@@ -399,6 +404,24 @@ declare module 'chrome://global/content/lit-utils.mjs' {
   export const SelectControlBaseElement: any;
   export const SelectControlItemMixin: any;
 }
+// MozLitElement with instance members Extra: what a widget casts its base
+// to for the getters static queries installs (and properties it declares
+// only in static properties). A class field would redefine a query getter
+// and throw, and a constructor declaration reads it before renderRoot.
+type MozLitElementWith<Extra> = Pick<
+  typeof import('chrome://global/content/lit-utils.mjs').MozLitElement,
+  keyof typeof import('chrome://global/content/lit-utils.mjs').MozLitElement
+> &
+  (new () => import('chrome://global/content/lit-utils.mjs').MozLitElement & Extra);
+`;
+/**
+ * Without typed Lit, `MozLitElementWith<Extra>` is `any`, as the base it
+ * casts is: the same widget source checks under per-patch checkJs and a
+ * project typecheck that leaves `litTypes` off.
+ */
+const LOOSE_LIT_SHIM = `
+// FireForge loose Lit (typecheck.litTypes off): see typecheck-shim.ts.
+type MozLitElementWith<Extra> = any;
 `;
 /** Hint appended to reported undefined-identifier diagnostics. */
 export const UNDEFINED_IDENTIFIER_HINT = '(undefined identifier — import or declare it, add the global to the extra shim, ' +
@@ -462,10 +485,11 @@ async function inlineTripleSlashReferences(source, baseDir, seen) {
  *   shim path
  * @param extraShimPath - Optional project-relative path to an extra `.d.ts`
  * @param options - `litTypes` appends {@link LIT_TYPES_SHIM} after the
- *   built-in shim (before the extra shim, which can still merge into it)
+ *   built-in shim (before the extra shim, which can still merge into it),
+ *   and {@link LOOSE_LIT_SHIM} otherwise
  */
 export async function composeShimSource(projectRoot, extraShimPath, options = {}) {
-    const base = options.litTypes === true ? `${FIREFOX_GLOBALS_SHIM}\n${LIT_TYPES_SHIM}` : FIREFOX_GLOBALS_SHIM;
+    const base = `${FIREFOX_GLOBALS_SHIM}\n${options.litTypes === true ? LIT_TYPES_SHIM : LOOSE_LIT_SHIM}`;
     if (!extraShimPath) {
         return { source: base, extraShimAppended: false };
     }

package/dist/src/types/furnace.d.ts

@@ -115,6 +115,13 @@ export interface FurnaceValidationException {
      * check for every other element of the component.
      */
     tag?: string;
+    /**
+     * Narrows the exception to the findings in this module file of the
+     * component (a finding's `files`), by file name: a vendored bundle whose
+     * bytes are pinned can be accepted without muting the check for the
+     * authored modules beside it.
+     */
+    file?: string;
     /** Why the finding is accepted. Required: the entry is the review record. */
     reason: string;
 }
@@ -379,6 +386,8 @@ export interface ValidationIssue {
     message: string;
     /** Element tags the finding is about, when it is about particular elements. */
     tags?: string[];
+    /** Component module files the finding is in (`hardcoded-text`), by file name. */
+    files?: string[];
 }
 /** Resolved test-harness selection for a `furnace create` run. */
 export type ResolvedTestStyle = 'mochikit' | 'browser-chrome' | 'xpcshell' | 'none';

package/docs/configuration.md

@@ -306,10 +306,26 @@ shim: `LitElement` and the helpers of
 member lists, as `Cu` does, so a misspelt member of a widget host is an
 error rather than `any`. Template helpers and directives stay loose. It is
 off by default because a reactive property declared only in
-`static properties` or `static queries` then needs a constructor
-assignment or a JSDoc declaration to be known. A project shim can add
-members by merging `interface LitElementShimMembers`; a jsconfig `paths`
-entry that maps these URLs to real sources takes precedence.
+`static properties` or `static queries` then needs a declaration to be
+known. Since 0.52.0 the shim declares the global type
+`MozLitElementWith<Extra>`: a widget casts its base to it, and its
+instances carry `Extra` beside MozLitElement's members. A query getter
+cannot be declared any other way: a class field redefines the getter
+MozLitElement installs and throws, and a constructor declaration reads it
+before `renderRoot` exists.
+
+```js
+const Base = /** @type {MozLitElementWith<{ input: HTMLInputElement }>} */ (MozLitElement);
+export class MozSearch extends Base {
+  static queries = { input: 'input' };
+}
+```
+
+Without `litTypes` (and under per-patch checkJs, which does not type Lit)
+`MozLitElementWith<Extra>` is `any`, as the base is, so the same source
+checks in both. A project shim can add members by merging
+`interface LitElementShimMembers`; a jsconfig `paths` entry that maps these
+URLs to real sources takes precedence.
 
 Per-patch checkJs gives each test script its own program. Since 0.51.0 a
 test's `resource:///` and `chrome://` imports (including a

package/docs/furnace.md

@@ -136,12 +136,30 @@ entries cover all of them:
 }
 ```
 
+An optional `file` (since 0.52.0) narrows an entry the same way to findings
+in one module of the component, by file name. `hardcoded-text` names the
+modules it found text in, so a vendored bundle whose bytes are pinned (and
+so cannot carry a `furnace-ignore` comment) can be accepted while the
+authored modules beside it keep the check. An entry names a `tag` or a
+`file`, not both:
+
+```json
+{
+  "component": "moz-editor",
+  "check": "hardcoded-text",
+  "file": "moz-editor-codemirror.mjs",
+  "reason": "The vendored bundle's width probe is never rendered."
+}
+```
+
 Accessibility checks judge the composed component: the host
 `<tag>.mjs` and its companion modules (`<tag>-*.mjs`, tests and stories
 left out) read as one source. Moving a template between the component's
 modules therefore no longer changes its findings: a keyboard handler in a
 companion covers an `@click` in the host, and an `@click` in a companion
-is judged too. Toolkit's `panel-item` counts as natively
+is judged too. `hardcoded-text` judges each module on its own, so a
+`// furnace-ignore: hardcoded-text` comment covers the file it is in, not
+its siblings. Toolkit's `panel-item` counts as natively
 keyboard-activated, beside `button`, form controls and the `moz-*` buttons.
 
 `minComponents` sets the fewest components a full `furnace validate` must

package/docs/machine-output.md

@@ -92,6 +92,8 @@ Additive keys since 0.51.0 outside `test`:
   `@click`). An exception that matched an error adds a
   `validation-exception-on-error` error, and a full run under
   `furnace.json#minComponents` a `component-floor` error on `furnace.json`.
+- `furnace validate --json` (since 0.52.0): a `hardcoded-text` finding
+  carries `files`, the component's module file names it was found in.
 
 ## Versioning
 
@@ -199,7 +201,9 @@ shard did not pass; under `--shard-size` `shards=` counts files and
 session lock shared, and `results=<path>` names the `--results` document. A
 run whose engine changed mid-run only in files the running browser cannot
 see keeps its verdict and appends `drift-tolerated=<n>`. A negative control
-on compiled source appends `control-build=compiled`.
+on compiled source appends `control-build=compiled`. Since 0.52.0 a raw log
+that starts none of a dispatch's requested files counts as
+`started=0/<m> ... started-source=raw` instead of leaving the run uncounted.
 
 ### The additive `shuffle=` key
 

package/docs/testing.md

@@ -112,7 +112,11 @@ install manifest ships) can only reach the binary through a build. Without
 `--build` it is refused before the lock. With `--build` it is applied before
 the pre-test build, so the binary under test carries it, stays applied for
 every `--repeat` run, and is restored with a fresh mtime so the next build
-recompiles the original. The verdict adds `control-build=compiled`. A
+recompiles the original. Since 0.52.0 that pre-test build is a full
+`mach build`, with a notice naming the control's files: the default
+`mach build faster` compiles nothing, so before, the control still tested
+the previous binary and reported `missed`. The verdict adds
+`control-build=compiled`. A
 build-less control whose packaging is not current is refused before the
 lock with the advice to add `--build`, instead of ending `inconclusive`
 after a full queue.
@@ -219,7 +223,12 @@ A scoped build after a full build keeps the claim full while nothing outside
 its scope moved. Otherwise it carries the full build's anchor forward, and a
 later build-less run over any path stays covered while that path's own
 staging inputs are unchanged since the full build. A refusal names the inputs
-that did change.
+that did change, and since 0.52.0 who wrote the coverage record: its
+invocation, when, and the writing process's pid (marked `still running`
+while it is), `FIREFORGE_SESSION_ID` and invocation id, the id its history
+records carry. `status --test-coverage` shows the pid and session too. A
+peer whose run a scoped build or a test-file edit refused can tell whose
+build to wait for.
 
 `--extend-coverage` remains accepted. Retention is now the default, so the
 flag only turns a drop into a refusal before the build. Before 0.50.0 a
@@ -582,10 +591,16 @@ helpers.
 `--jobs <n>` runs a request's shards on n harness instances inside one lock
 hold. Each instance has its own profile and its own Marionette port, and
 auto ports (required) move each instance's mochitest server ports; output
-lines carry a `[job <i>]` prefix in the terminal and the run log. With
-`--no-shard`, or a single directory argument, the files are split in order
-into n contiguous chunks. Parallel browsers raise host load, so measure
-before relying on it.
+lines carry a `[job <i>]` prefix in the terminal and the run log. Since
+0.52.0 each instance also writes its own mochitest test list
+(`--testrun-manifest-file`): on the harness's shared default
+`_tests/testing/mochitest/tests.json`, the second instance ran the first
+shard's file and passed, or found none. A `--jobs` run always reads each
+dispatch's mozlog raw log, and a dispatch whose raw log starts none of its
+requested files fails with `started=0/<m>` instead of passing on another
+shard's results. With `--no-shard`, or a single directory argument, the
+files are split in order into n contiguous chunks. Parallel browsers raise
+host load, so measure before relying on it.
 
 `--shard-size <n>` dispatches n files per mach invocation (mochitest restarts
 the browser between files), paying the harness start once per chunk instead

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",