@hominis/fireforge 0.50.0 → 0.52.0

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

@@ -1,12 +1,38 @@
 // SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
 import { createIssue } from './furnace-validate-helpers.js';
 import { countUnlabelledIconButtons } from './furnace-validate-icon-button.js';
 import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-template-regions.js';
 /**
- * Validates accessibility patterns in a component's .mjs file.
- * Checks for ARIA roles, keyboard handlers, l10n, and focus delegation.
+ * Reads the composed component: `<tagName>.mjs` followed by its companion
+ * modules (`<tagName>-*.mjs`, tests and stories left out), so a template's
+ * findings do not depend on which of the component's modules it lives in.
+ * Returns undefined when the host module is missing.
+ */
+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(() => []);
+    const companions = entries
+        .filter((name) => name.startsWith(`${tagName}-`) &&
+        name.endsWith('.mjs') &&
+        !/\.(test|spec|stories)\./.test(name))
+        .sort();
+    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
+ * host module and every companion module (see
+ * {@link readComposedComponentSource}). Checks for ARIA roles, keyboard
+ * handlers, l10n, and focus delegation.
  *
  * @param componentDir - Directory holding the component's sources
  * @param tagName - Custom element tag name, used to locate `<tagName>.mjs`
@@ -20,10 +46,10 @@ import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-templa
  *   adds the icon-only `<moz-button>` naming check.
  */
 export async function validateAccessibility(componentDir, tagName, customConfig, optInChecks = []) {
-    const mjsPath = join(componentDir, `${tagName}.mjs`);
-    if (!(await pathExists(mjsPath)))
+    const modules = await readComposedComponentModules(componentDir, tagName);
+    if (modules === undefined)
         return [];
-    const content = await readText(mjsPath);
+    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.'));
@@ -41,13 +67,24 @@ export async function validateAccessibility(componentDir, tagName, customConfig,
     // activation flows through the inner element and a duplicate handler on
     // the wrapper would either no-op or fire twice alongside the child's
     // built-in keyboard path.
-    const hasClickOnSynthetic = hasTemplateClickOnSyntheticInteractive(content);
+    const syntheticTags = syntheticClickTags(content);
     const keyboardCovered = isKeyboardCoveredByComposition(customConfig);
-    if (hasClickOnSynthetic && !hasKeyboardHandler && !keyboardCovered) {
-        issues.push(createIssue(tagName, 'warning', 'no-keyboard-handler', 'Interactive element has @click but no keyboard event handler (@keydown/@keypress/@keyup).'));
+    if (syntheticTags.length > 0 && !hasKeyboardHandler && !keyboardCovered) {
+        issues.push({
+            ...createIssue(tagName, 'warning', 'no-keyboard-handler', `Interactive element has @click but no keyboard event handler (@keydown/@keypress/@keyup), on ${syntheticTags.map((tag) => `<${tag}>`).join(', ')}.`),
+            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)) {
@@ -164,6 +201,9 @@ const NATIVE_CLICK_INTERACTIVE_TAGS = new Set([
     'moz-radio',
     'moz-radio-group',
     'moz-menulist',
+    // Toolkit's panel-list row renders a button that takes Enter and Space
+    // and dispatches click.
+    'panel-item',
 ]);
 /**
  * Returns true when `customConfig` declares that the component's keyboard
@@ -185,28 +225,33 @@ function isKeyboardCoveredByComposition(customConfig) {
     return composes.some((tag) => NATIVE_CLICK_INTERACTIVE_TAGS.has(tag));
 }
 /**
- * Returns true when `content` has at least one `@click=${...}` handler on a
- * *synthetic* interactive element (e.g. `<div @click>`), which lacks native
- * keyboard activation and therefore needs an explicit key handler for
- * Enter/Space. Returns false when every `@click` handler sits on a native
- * interactive element. Those already fire `click` on keyboard activation.
+ * Returns the tags (in first-seen order) of every *synthetic* interactive
+ * element carrying an `@click=${...}` handler (e.g. `<div @click>`), which
+ * lacks native keyboard activation and therefore needs an explicit key
+ * handler for Enter/Space. Empty when every `@click` handler sits on a
+ * native interactive element. Those already fire `click` on keyboard
+ * activation.
  */
-function hasTemplateClickOnSyntheticInteractive(content) {
+function syntheticClickTags(content) {
     const pattern = /@click\s*=\s*\$\{/g;
+    const tags = [];
     let match;
     while ((match = pattern.exec(content)) !== null) {
-        if (isClickOnSyntheticInteractive(content, match.index)) {
-            return true;
-        }
+        const tag = syntheticClickTag(content, match.index);
+        if (tag !== undefined && !tags.includes(tag))
+            tags.push(tag);
     }
-    return false;
+    return tags;
 }
+/** The tag a synthetic-element `@click` sits on, `?` when it cannot be told. */
+const UNKNOWN_TAG = '?';
 /**
  * Given the offset of an `@click=${...}` occurrence, walks backwards to find
- * the opening `<tag` that owns it and decides whether that tag is a native
- * interactive element (no warning needed) or a synthetic one (warning needed).
+ * the opening `<tag` that owns it and returns that tag when it is a
+ * synthetic interactive element (warning needed), or undefined when it is a
+ * native one (no warning needed).
  */
-function isClickOnSyntheticInteractive(content, clickIndex) {
+function syntheticClickTag(content, clickIndex) {
     // Find the nearest preceding `<` that starts a tag (skip `</` closers).
     let i = clickIndex - 1;
     let tagOpenIndex = -1;
@@ -219,15 +264,15 @@ function isClickOnSyntheticInteractive(content, clickIndex) {
         // which shouldn't happen for a well-formed template but we defensively
         // treat it as synthetic to preserve the prior-behaviour warning.
         if (content[i] === '>') {
-            return true;
+            return UNKNOWN_TAG;
         }
         i--;
     }
     if (tagOpenIndex < 0)
-        return true;
+        return UNKNOWN_TAG;
     const tagMatch = /^<([a-zA-Z][a-zA-Z0-9-]*)/.exec(content.slice(tagOpenIndex));
     if (!tagMatch?.[1])
-        return true;
+        return UNKNOWN_TAG;
     const tagName = tagMatch[1].toLowerCase();
     if (tagName === 'a') {
         // Bare <a> (no href) is non-interactive, so require a keyboard handler.
@@ -235,11 +280,11 @@ function isClickOnSyntheticInteractive(content, clickIndex) {
         // attribute text in between for an href attribute.
         const tagEnd = content.indexOf('>', tagOpenIndex);
         if (tagEnd < 0)
-            return true;
+            return 'a';
         const attrs = content.slice(tagOpenIndex, tagEnd);
-        return !/\shref\s*=/.test(attrs);
+        return /\shref\s*=/.test(attrs) ? undefined : 'a';
     }
-    return !NATIVE_CLICK_INTERACTIVE_TAGS.has(tagName);
+    return NATIVE_CLICK_INTERACTIVE_TAGS.has(tagName) ? undefined : tagName;
 }
 /** ASCII punctuation that reads as decoration rather than localizable text. */
 const SYMBOL_ONLY_ASCII = '+-*=<>|/\\^~@#&!?%';
@@ -303,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

@@ -1,14 +1,23 @@
 /**
  * Applies `furnace.json#validationExceptions[]` to a `furnace validate`
  * result. An exception suppresses every finding of its check on its
- * component. 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`.
+ * component, or with `tag`, a finding whose element tags it (and its
+ * 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`.
+ *
+ * An exception never suppresses an error: an error blocks apply, and a
+ * review record cannot make a broken component deployable. The error stays
+ * counted and the matching entry is reported as
+ * `validation-exception-on-error`.
  */
 import type { FurnaceValidationException, ValidationIssue } from '../types/furnace.js';
 /** The check name of the warning a stale exception produces. */
 export declare const STALE_VALIDATION_EXCEPTION_CHECK = "stale-validation-exception";
+/** The check name of the error an exception matching an error produces. */
+export declare const EXCEPTION_ON_ERROR_CHECK = "validation-exception-on-error";
 /** A finding an exception suppressed, with the exception's reason. */
 export interface ExceptedValidationIssue extends ValidationIssue {
     reason: string;

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

@@ -1,9 +1,40 @@
 import { createIssue } from './furnace-validate-helpers.js';
 /** The check name of the warning a stale exception produces. */
 export const STALE_VALIDATION_EXCEPTION_CHECK = 'stale-validation-exception';
+/** The check name of the error an exception matching an error produces. */
+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 unscoped one alone, or scoped
+ * ones that together cover every tag (or every file) the finding names.
+ */
+function coveringExceptions(issue, candidates) {
+    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.
  *
@@ -18,14 +49,38 @@ export function applyValidationExceptions(issues, exceptions, judged) {
     const outcome = { issues: [], excepted: [], stale: [] };
     const list = exceptions ?? [];
     const used = new Set();
+    const onError = new Set();
     for (const issue of issues) {
-        const exception = list.find((entry) => matches(entry, issue));
-        if (exception === undefined) {
+        const candidates = list.filter((entry) => matches(entry, issue));
+        if (issue.severity === 'error') {
+            for (const entry of candidates) {
+                used.add(entry);
+                onError.add(entry);
+            }
             outcome.issues.push(issue);
             continue;
         }
-        used.add(exception);
-        outcome.excepted.push({ ...issue, reason: exception.reason });
+        const covering = coveringExceptions(issue, candidates);
+        if (covering.length === 0) {
+            // 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) {
+                const scope = scopeOf(entry);
+                if (scope !== undefined && issue[scope.key]?.includes(scope.value) === true) {
+                    used.add(entry);
+                }
+            }
+            outcome.issues.push(issue);
+            continue;
+        }
+        for (const entry of covering)
+            used.add(entry);
+        outcome.excepted.push({ ...issue, reason: covering.map((entry) => entry.reason).join('; ') });
+    }
+    for (const exception of onError) {
+        outcome.issues.push(createIssue(exception.component, 'error', EXCEPTION_ON_ERROR_CHECK, `furnace.json validationExceptions entry for [${exception.check}] matches an error, ` +
+            'which an exception cannot suppress. Fix the error, then delete the entry.'));
     }
     for (const exception of list) {
         if (used.has(exception) || !judged(exception.component))

package/dist/src/core/furnace-validate-icon-button.js

@@ -18,10 +18,39 @@ import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-templa
 const NAMING_ATTRIBUTES = ['data-l10n-id', 'aria-label', '.arialabel'];
 /** Attributes that give the button a visible label, so it is not icon-only. */
 const LABEL_ATTRIBUTES = ['label', '.label'];
+/**
+ * Whether the button's content has a non-blank character outside tags.
+ * Scans instead of stripping tags, so nested or unbalanced markup cannot
+ * leave a fragment behind that reads as text, and a `>` inside a quoted
+ * attribute value does not end its tag.
+ */
+function hasVisibleText(markup) {
+    let inTag = false;
+    let quote;
+    for (const char of markup) {
+        if (quote !== undefined) {
+            if (char === quote)
+                quote = undefined;
+        }
+        else if (inTag) {
+            if (char === '"' || char === "'")
+                quote = char;
+            else if (char === '>')
+                inTag = false;
+        }
+        else if (char === '<') {
+            inTag = true;
+        }
+        else if (char.trim() !== '') {
+            return true;
+        }
+    }
+    return false;
+}
 function isIconOnly(attrs, innerText) {
     if (LABEL_ATTRIBUTES.some((name) => attrs.has(name)))
         return false;
-    if (innerText.replace(/<[^>]*>/g, '').trim().length > 0)
+    if (hasVisibleText(innerText))
         return false;
     const type = attrs.get('type') ?? '';
     return attrs.has('iconsrc') || attrs.has('.iconsrc') || /(^|\s)icon(\s|$)/.test(type);

package/dist/src/core/history-log-file.js

@@ -17,7 +17,7 @@ import { randomUUID } from 'node:crypto';
 import { appendFile, link, readFile, rename, rm, stat } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { getNodeErrorCode, toError } from '../utils/errors.js';
-import { ensureDir } from '../utils/fs.js';
+import { ensureDir, pathExists } from '../utils/fs.js';
 import { info, verbose } from '../utils/logger.js';
 import { FIREFORGE_DIR } from './config-paths.js';
 import { isValidHistoryPath } from './config-validate-history.js';
@@ -131,6 +131,13 @@ export async function migrateLegacyHistoryLog(patchesDir, target) {
         await link(claimed, target);
     }
     catch (error) {
+        // Windows can report two racing renames of one file as both
+        // succeeding, the file ending under the other claimant's name. That
+        // claimant holds the records and moves them, so this one stands down.
+        if (getNodeErrorCode(error) === 'ENOENT' && !(await pathExists(claimed))) {
+            verbose('History log migration lost the claim to a concurrent command');
+            return;
+        }
         // EEXIST: both logs exist. Anything else (a filesystem without hard
         // links, a target on another device): the append below creates the
         // target when it is missing, so it covers that case too.

package/dist/src/core/line-prefixer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Prefixes every line of a chunked stream, for output from several
+ * concurrent harness instances (`fireforge test --jobs`) that share one
+ * terminal and one run log. Without a prefix, interleaved lines from two
+ * browsers cannot be attributed after the fact.
+ */
+/** A stateful line prefixer for one stream. */
+export interface LinePrefixer {
+    /** Returns `chunk` with the prefix inserted at the start of each line. */
+    transform(chunk: string): string;
+}
+/**
+ * Creates a prefixer. Line state carries across chunks, so a line split
+ * between two chunks gets the prefix exactly once.
+ *
+ * @param prefix - Text to insert, e.g. `[job 2] `
+ */
+export declare function createLinePrefixer(prefix: string): LinePrefixer;

package/dist/src/core/line-prefixer.js

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Prefixes every line of a chunked stream, for output from several
+ * concurrent harness instances (`fireforge test --jobs`) that share one
+ * terminal and one run log. Without a prefix, interleaved lines from two
+ * browsers cannot be attributed after the fact.
+ */
+/**
+ * Creates a prefixer. Line state carries across chunks, so a line split
+ * between two chunks gets the prefix exactly once.
+ *
+ * @param prefix - Text to insert, e.g. `[job 2] `
+ */
+export function createLinePrefixer(prefix) {
+    let atLineStart = true;
+    return {
+        transform(chunk) {
+            if (chunk.length === 0)
+                return chunk;
+            let out = '';
+            let start = 0;
+            for (let index = chunk.indexOf('\n'); index !== -1; index = chunk.indexOf('\n', start)) {
+                out += `${atLineStart ? prefix : ''}${chunk.slice(start, index + 1)}`;
+                atLineStart = true;
+                start = index + 1;
+            }
+            if (start < chunk.length) {
+                out += `${atLineStart ? prefix : ''}${chunk.slice(start)}`;
+                atLineStart = false;
+            }
+            return out;
+        },
+    };
+}

package/dist/src/core/mach.d.ts

@@ -47,6 +47,11 @@ export interface MachOptions {
     onProcessGroup?: (pgid: number) => void;
     /** Exec-layer hook, see {@link ProcessGroupOptions.postCloseSweep}. Capture-only. */
     postCloseSweep?: () => Promise<void>;
+    /**
+     * Prefix for every echoed and logged line (concurrent `test --jobs`
+     * instances). The capture and `onOutputChunk` stay raw. Capture-only.
+     */
+    outputPrefix?: string | undefined;
 }
 /**
  * Result of running a mach command while capturing streamed output.
@@ -263,6 +268,8 @@ export interface MachTestSuiteOptions {
      * the harness launched. See {@link MachOptions}.
      */
     teardown?: Pick<MachOptions, 'onOutputChunk' | 'onProcessGroup' | 'postCloseSweep'> | undefined;
+    /** Line prefix for echo and run log, see {@link MachOptions.outputPrefix}. */
+    outputPrefix?: string | undefined;
 }
 /**
  * Runs one mach test command (`mach test` / `mach xpcshell-test` / `mach

package/dist/src/core/mach.js

@@ -7,6 +7,7 @@ import { exec, execInherit, execInheritCapture, execSmokeRun, execStream, } from
 import { withBuildRunRecord } from './build-run-record.js';
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
 import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
+import { createLinePrefixer } from './line-prefixer.js';
 import { explainMachError } from './mach-error-hints.js';
 import { createKnownTeardownNoiseFilter, createTeardownNoiseContext, hasKnownTeardownNoise, KNOWN_TEARDOWN_NOISE_BUILD_NOTE, } from './mach-known-noise-filter.js';
 import { getPython } from './mach-python.js';
@@ -89,6 +90,15 @@ export async function runMachCapture(args, engineDir, options = {}) {
     const noiseContext = options.annotateKnownTeardownNoise === true ? createTeardownNoiseContext() : undefined;
     const stdoutFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
     const stderrFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
+    const prefix = options.outputPrefix;
+    const prefixers = prefix === undefined
+        ? undefined
+        : {
+            stdoutLog: createLinePrefixer(prefix),
+            stdoutEcho: createLinePrefixer(prefix),
+            stderrLog: createLinePrefixer(prefix),
+            stderrEcho: createLinePrefixer(prefix),
+        };
     const exitCode = await execStream(python, [machPath, ...args], {
         cwd: engineDir,
         ...(options.env ? { env: options.env } : {}),
@@ -110,8 +120,9 @@ export async function runMachCapture(args, engineDir, options = {}) {
             // echo filter only exists to shorten what a human scrolls past.
             // Collapsing a traceback in the artifact would reintroduce the loss
             // this log exists to prevent.
-            writeToActiveRunLog(data);
-            process.stdout.write(stdoutFilter ? stdoutFilter.transform(data) : data);
+            writeToActiveRunLog(prefixers ? prefixers.stdoutLog.transform(data) : data);
+            const echo = stdoutFilter ? stdoutFilter.transform(data) : data;
+            process.stdout.write(prefixers ? prefixers.stdoutEcho.transform(echo) : echo);
         },
         onStderr: (data) => {
             options.onOutputChunk?.('stderr', data);
@@ -119,19 +130,22 @@ export async function runMachCapture(args, engineDir, options = {}) {
             if (stderr.length > CAPTURE_TAIL_LIMIT) {
                 stderr = stderr.slice(-CAPTURE_TAIL_LIMIT);
             }
-            writeToActiveRunLog(data);
-            process.stderr.write(stderrFilter ? stderrFilter.transform(data) : data);
+            writeToActiveRunLog(prefixers ? prefixers.stderrLog.transform(data) : data);
+            const echo = stderrFilter ? stderrFilter.transform(data) : data;
+            process.stderr.write(prefixers ? prefixers.stderrEcho.transform(echo) : echo);
         },
     });
     if (stdoutFilter) {
         const residue = stdoutFilter.flush();
-        if (residue.length > 0)
-            process.stdout.write(residue);
+        if (residue.length > 0) {
+            process.stdout.write(prefixers ? prefixers.stdoutEcho.transform(residue) : residue);
+        }
     }
     if (stderrFilter) {
         const residue = stderrFilter.flush();
-        if (residue.length > 0)
-            process.stderr.write(residue);
+        if (residue.length > 0) {
+            process.stderr.write(prefixers ? prefixers.stderrEcho.transform(residue) : residue);
+        }
     }
     return { stdout, stderr, exitCode };
 }
@@ -418,13 +432,14 @@ function testVerbosityEnvUnset(fullOutput) {
  * @param options - Engine checkout, test paths, extra args, env, verbosity
  */
 export async function runMachTestSuite(kind, options) {
-    const { engineDir, testPaths = [], args = [], env, fullOutput, teardown } = options;
+    const { engineDir, testPaths = [], args = [], env, fullOutput, teardown, outputPrefix } = options;
     const guard = await installMachResourceGuard(engineDir);
     const envUnset = testVerbosityEnvUnset(fullOutput);
     return runMachCapture([kind, ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
         ...(envUnset ? { envUnset } : {}),
         ...teardown,
+        ...(outputPrefix === undefined ? {} : { outputPrefix }),
         annotateKnownTeardownNoise: true,
     });
 }

package/dist/src/core/module-resolution-preflight.d.ts

@@ -18,6 +18,12 @@
  * no owned file is an upstream Firefox module, which FireForge does not
  * police and cannot cheaply enumerate. Policing only what the fork owns is
  * both the actionable set and the one that produces real incidents.
+ *
+ * An unscoped `verify` widens that set with the engine worktree: changed
+ * files import, and untracked files are targets. A chrome script's lazy
+ * getter for a new, not yet exported `.sys.mjs` with no moz.build line
+ * SIGSEGVed every start of a shared objdir, and neither file was in the
+ * queue yet, so the queue-only scan could not see it.
  */
 /** Why a queue-owned module import does not resolve to a packaged module. */
 export type UnresolvedModuleReason = 'missing-file' | 'unregistered';
@@ -31,16 +37,26 @@ export interface UnresolvedModuleImport {
     importers: string[];
     reason: UnresolvedModuleReason;
 }
+/** Engine worktree files the preflight also judges, beside the queue's. */
+export interface WorktreeModuleFiles {
+    /** Changed or untracked files: scanned for imports. */
+    changed: readonly string[];
+    /** Untracked files: new modules the fork has not exported yet. */
+    untracked: readonly string[];
+}
+/** Lists the engine's changed and untracked files for the worktree scan. */
+export declare function collectWorktreeModuleFiles(engineDir: string): Promise<WorktreeModuleFiles>;
 /**
  * Resolves every `resource://` system-module import made by the
- * queue-owned files and reports the ones a packaged browser could not
- * load.
+ * queue-owned files (and, given `worktree`, by changed engine files) and
+ * reports the ones a packaged browser could not load.
  *
  * @param engineDir - Path to the engine checkout
  * @param ownedFiles - Engine-relative paths the patch queue owns
+ * @param worktree - Changed and untracked engine files to judge as well
  * @returns Findings sorted by module path. Empty when everything resolves
  */
-export declare function findUnresolvedSystemModuleImports(engineDir: string, ownedFiles: readonly string[]): Promise<UnresolvedModuleImport[]>;
+export declare function findUnresolvedSystemModuleImports(engineDir: string, ownedFiles: readonly string[], worktree?: WorktreeModuleFiles): Promise<UnresolvedModuleImport[]>;
 /**
  * Renders findings as operator-facing lines, naming the unregistered or
  * unresolvable module, so the failure is a sentence instead of a bare

package/dist/src/core/module-resolution-preflight.js

@@ -19,12 +19,19 @@
  * no owned file is an upstream Firefox module, which FireForge does not
  * police and cannot cheaply enumerate. Policing only what the fork owns is
  * both the actionable set and the one that produces real incidents.
+ *
+ * An unscoped `verify` widens that set with the engine worktree: changed
+ * files import, and untracked files are targets. A chrome script's lazy
+ * getter for a new, not yet exported `.sys.mjs` with no moz.build line
+ * SIGSEGVed every start of a shared objdir, and neither file was in the
+ * queue yet, so the queue-only scan could not see it.
  */
 import { dirname, join } from 'node:path';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { escapeRegex } from '../utils/regex.js';
+import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from './git-status.js';
 import { extractResourceModuleSpecifiers, moduleSourceSuffix, } from './patch-lint-module-registration.js';
 /** Extensions whose contents are scanned for resource-module imports. */
 const IMPORTABLE_EXTENSIONS = ['.mjs', '.sys.mjs', '.js', '.jsm'];
@@ -79,20 +86,31 @@ async function isRegisteredInAncestorMozBuild(engineDir, moduleRelPath, mozBuild
         dir = parent;
     }
 }
+/** Lists the engine's changed and untracked files for the worktree scan. */
+export async function collectWorktreeModuleFiles(engineDir) {
+    const entries = await expandUntrackedDirectoryEntries(engineDir, await getWorkingTreeStatus(engineDir));
+    const present = entries.filter((entry) => entry.worktreeStatus !== 'D');
+    return {
+        changed: present.map((entry) => entry.file),
+        untracked: present.filter((entry) => entry.status === '??').map((entry) => entry.file),
+    };
+}
 /**
  * Resolves every `resource://` system-module import made by the
- * queue-owned files and reports the ones a packaged browser could not
- * load.
+ * queue-owned files (and, given `worktree`, by changed engine files) and
+ * reports the ones a packaged browser could not load.
  *
  * @param engineDir - Path to the engine checkout
  * @param ownedFiles - Engine-relative paths the patch queue owns
+ * @param worktree - Changed and untracked engine files to judge as well
  * @returns Findings sorted by module path. Empty when everything resolves
  */
-export async function findUnresolvedSystemModuleImports(engineDir, ownedFiles) {
-    const owned = [...new Set(ownedFiles)];
-    /** specifier → importing owned files. */
+export async function findUnresolvedSystemModuleImports(engineDir, ownedFiles, worktree) {
+    const owned = [...new Set([...ownedFiles, ...(worktree?.untracked ?? [])])];
+    const importing = [...new Set([...owned, ...(worktree?.changed ?? [])])];
+    /** specifier → importing files. */
     const importersBySpecifier = new Map();
-    for (const file of owned) {
+    for (const file of importing) {
         if (!IMPORTABLE_EXTENSIONS.some((extension) => file.endsWith(extension)))
             continue;
         const content = await readIfPresent(join(engineDir, file));