@hominis/fireforge 0.40.0 → 0.42.0

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

@@ -26,6 +26,7 @@
  * while reporting only the patch under export.
  */
 import { basename, resolve } from 'node:path';
+import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES, TEST_HARNESS_SHIM, UNDEFINED_IDENTIFIER_CODES, UNDEFINED_IDENTIFIER_HINT, } from './typecheck-shim.js';
@@ -146,9 +147,17 @@ function createPathsResolver(ts, paths, baseDir, fileExists, onResolved) {
  *   the built-in Firefox-globals shim (from `patchLint.checkJsExtraShim`)
  * @param projectRoot - Absolute project root for resolving `extraShimPath`
  * @param mode - Strictness preset plus allowlisted compiler-option overrides
+ * @param builtinShimSuffix - Optional shim text appended AFTER the consumer shim
+ * @param rootScope - When set, only these repo-relative files become program
+ *   ROOTS; resolution (and the host allowlist) still spans all of
+ *   `resolutionOwned`, so a subset root's cross-patch imports type-check
+ *   against the real owning sources while unrelated owned files are never
+ *   parsed. `.mjs` files are module-scoped, so a root's diagnostics are
+ *   identical whether other owned files are roots or mere resolution
+ *   targets (pinned by the rootScope parity test — FORGE J1c).
  * @returns Diagnostics grouped per owning file plus run-level errors
  */
-export async function runCheckJsGrouped(repoDir, resolutionOwned, extraShimPath, projectRoot, mode, builtinShimSuffix) {
+export async function runCheckJsGrouped(repoDir, resolutionOwned, extraShimPath, projectRoot, mode, builtinShimSuffix, rootScope) {
     const empty = { byFile: new Map(), global: [] };
     if (resolutionOwned.size === 0)
         return empty;
@@ -171,14 +180,18 @@ export async function runCheckJsGrouped(repoDir, resolutionOwned, extraShimPath,
             ],
         };
     }
-    // Resolve absolute paths for root files, filtering to files that exist
+    // Resolve absolute paths for root files, filtering to files that exist.
+    // Under a rootScope, non-scoped owned files stay resolvable (host
+    // allowlist + relByAbsolute) but are not program roots — they are only
+    // parsed if a scoped root's import closure reaches them.
     const rootFiles = [];
     const ownedAbsolute = new Set();
     const relByAbsolute = new Map();
     for (const rel of resolutionOwned) {
         const abs = resolve(repoDir, rel);
         if (await pathExists(abs)) {
-            rootFiles.push(abs);
+            if (rootScope === undefined || rootScope.has(rel))
+                rootFiles.push(abs);
             ownedAbsolute.add(abs);
             relByAbsolute.set(abs, rel);
         }
@@ -209,7 +222,7 @@ export async function runCheckJsGrouped(repoDir, resolutionOwned, extraShimPath,
                 {
                     file: extraShimPath ?? '(checkJs)',
                     check: 'checkjs-type-error',
-                    message: err instanceof Error ? err.message : String(err),
+                    message: toError(err).message,
                     severity: 'error',
                 },
             ],
@@ -423,7 +436,7 @@ export async function invokePatchLintCheckJs(repoDir, patchOwnedFiles, patchLint
  * @param patchLint - The resolved `patchLint` config block
  * @param projectRoot - FireForge project root for shim resolution
  */
-export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint, projectRoot) {
+export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint, projectRoot, rootScope) {
     const merged = { byFile: new Map(), global: [] };
     if (testFiles.size === 0)
         return merged;
@@ -431,6 +444,11 @@ export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint,
     const seenGlobal = new Set();
     const files = [...testFiles].sort((a, b) => a.localeCompare(b));
     for (const file of files) {
+        // Under a rootScope only the scoped files get their own program, but
+        // head.js helper discovery still spans the full owned set so a scoped
+        // test keeps its cross-patch harness globals (FORGE J1c).
+        if (rootScope !== undefined && !rootScope.has(file))
+            continue;
         const dir = file.slice(0, file.lastIndexOf('/') + 1);
         const roots = new Set([file]);
         for (const candidate of files) {
@@ -479,7 +497,60 @@ function modeFromPatchLintConfig(patchLint) {
  * @param patchOwnedFiles - Every patch-owned `.sys.mjs` in the queue
  * @param patchLint - The resolved `patchLint` config block
  * @param projectRoot - FireForge project root for shim resolution
+ * @param rootScope - Optional subset of files to use as program roots
+ *   (`--patches`); resolution still spans the whole queue (FORGE J1c)
+ */
+export async function invokePatchLintCheckJsGrouped(repoDir, patchOwnedFiles, patchLint, projectRoot, rootScope) {
+    return runCheckJsGrouped(repoDir, patchOwnedFiles, patchLint.checkJsExtraShim, projectRoot, modeFromPatchLintConfig(patchLint), undefined, rootScope);
+}
+/**
+ * Cheap probe reproducing the only run-level ("global") checkJs findings
+ * the build path can produce — a missing `typescript` package and an
+ * unreadable consumer shim (`checkJsExtraShim`, and `checkJsTestShim`
+ * when `checkJsTestFiles` is on). The built program itself never
+ * contributes globals (see {@link runCheckJsGrouped}), so a warm
+ * all-cache-hit run can satisfy the "warm never reports less than cold"
+ * invariant (FORGE F5) with this probe instead of building the whole
+ * TypeScript program. Issue objects are byte-identical to the build
+ * path's, deduplicated by message like {@link runCheckJsTestFilesGrouped}.
  */
-export async function invokePatchLintCheckJsGrouped(repoDir, patchOwnedFiles, patchLint, projectRoot) {
-    return runCheckJsGrouped(repoDir, patchOwnedFiles, patchLint.checkJsExtraShim, projectRoot, modeFromPatchLintConfig(patchLint));
+export async function probeCheckJsGlobalIssues(patchLint, projectRoot) {
+    try {
+        await import('typescript');
+    }
+    catch {
+        return [
+            {
+                file: '(checkJs)',
+                check: 'checkjs-type-error',
+                message: 'patchLint.checkJs is enabled but the "typescript" package is not installed. ' +
+                    'Run "npm install typescript" to enable type checking.',
+                severity: 'error',
+            },
+        ];
+    }
+    const issues = [];
+    const seen = new Set();
+    const probeShim = async (shimPath) => {
+        try {
+            await composeShimSource(projectRoot, shimPath);
+        }
+        catch (err) {
+            const message = toError(err).message;
+            if (seen.has(message))
+                return;
+            seen.add(message);
+            issues.push({
+                file: shimPath ?? '(checkJs)',
+                check: 'checkjs-type-error',
+                message,
+                severity: 'error',
+            });
+        }
+    };
+    await probeShim(patchLint.checkJsExtraShim);
+    if (patchLint.checkJsTestFiles === true) {
+        await probeShim(patchLint.checkJsTestShim);
+    }
+    return issues;
 }

package/dist/src/core/patch-lint-chrome-jsdoc.js

@@ -40,6 +40,15 @@ export function validateChromeScriptJsDoc(source, options) {
         ast = parseScript(source, comments);
     }
     catch {
+        // Deliberate carve-out, unlike the `.sys.mjs` walker in
+        // `patch-lint-jsdoc.ts` (which reports a parse failure as an issue).
+        // `parseScript` rejects `import`/`export`, so a chrome subscript that was
+        // misclassified as a `.js` file — or that mistakenly uses module syntax —
+        // would emit a pseudo-issue for every rule here. The orchestrator already
+        // runs the export walker on `.sys.mjs` separately, so silently declining
+        // to lint an unparseable script is the correct degradation for this file
+        // and only this file. Pinned by "returns no issues when the source uses
+        // module-only syntax" in patch-lint-chrome-jsdoc.test.ts.
         return [];
     }
     const issues = [];

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

@@ -0,0 +1,30 @@
+/**
+ * New-file creators map for the patch queue, split out of
+ * `patch-lint-cross.ts` (at the per-file line budget). Re-exported from
+ * there so callers keep importing from `patch-lint.ts` unchanged.
+ *
+ * Memoised per context object (FORGE J1): ownership resolution and
+ * cache-key fingerprints call this 2-3× per linted patch, and each call
+ * used to re-run `detectNewFilesInDiff` over EVERY queue entry's diff.
+ * Keyed weakly so a discarded context frees its map; a caller that
+ * mutates a context entry in place must call
+ * {@link invalidateNewFileCreatorsCache}.
+ */
+/** The slice of a queue context the creators map is derived from. */
+interface CreatorsContext {
+    entries: {
+        filename: string;
+        diff: string;
+    }[];
+}
+/** Drops the memoised creators map after an in-place context entry update. */
+export declare function invalidateNewFileCreatorsCache(ctx: CreatorsContext): void;
+/**
+ * Returns the raw `path → patches[]` map of files created in `new file
+ * mode` by at least one patch in the queue. Paths created by only one
+ * patch are also included so callers can distinguish "no creator" from
+ * "exactly one creator" without re-scanning the diffs. The returned map
+ * is memoised and shared — treat it as read-only.
+ */
+export declare function collectNewFileCreatorsByPath(ctx: CreatorsContext): Map<string, string[]>;
+export {};

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

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * New-file creators map for the patch queue, split out of
+ * `patch-lint-cross.ts` (at the per-file line budget). Re-exported from
+ * there so callers keep importing from `patch-lint.ts` unchanged.
+ *
+ * Memoised per context object (FORGE J1): ownership resolution and
+ * cache-key fingerprints call this 2-3× per linted patch, and each call
+ * used to re-run `detectNewFilesInDiff` over EVERY queue entry's diff.
+ * Keyed weakly so a discarded context frees its map; a caller that
+ * mutates a context entry in place must call
+ * {@link invalidateNewFileCreatorsCache}.
+ */
+import { detectNewFilesInDiff } from './patch-lint-diff.js';
+const newFileCreatorsMemo = new WeakMap();
+/** Drops the memoised creators map after an in-place context entry update. */
+export function invalidateNewFileCreatorsCache(ctx) {
+    newFileCreatorsMemo.delete(ctx);
+}
+/**
+ * Returns the raw `path → patches[]` map of files created in `new file
+ * mode` by at least one patch in the queue. Paths created by only one
+ * patch are also included so callers can distinguish "no creator" from
+ * "exactly one creator" without re-scanning the diffs. The returned map
+ * is memoised and shared — treat it as read-only.
+ */
+export function collectNewFileCreatorsByPath(ctx) {
+    const memoised = newFileCreatorsMemo.get(ctx);
+    if (memoised)
+        return memoised;
+    const creators = new Map();
+    for (const entry of ctx.entries) {
+        const newFiles = detectNewFilesInDiff(entry.diff);
+        for (const file of newFiles) {
+            let owners = creators.get(file);
+            if (!owners) {
+                owners = [];
+                creators.set(file, owners);
+            }
+            owners.push(entry.filename);
+        }
+    }
+    newFileCreatorsMemo.set(ctx, creators);
+    return creators;
+}

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

@@ -79,23 +79,7 @@ export interface PatchQueueContext {
  * @param patchesDir - Path to the patches directory
  */
 export declare function buildPatchQueueContext(patchesDir: string, config?: FireForgeConfig): Promise<PatchQueueContext>;
-/**
- * Returns the raw `path → patches[]` map of files created in `new file
- * mode` by at least one patch in the queue. Paths created by only one
- * patch are also included so callers can distinguish "no creator" from
- * "exactly one creator" without re-scanning the diffs.
- *
- * Split out from {@link lintPatchQueueDuplicateCreations} so
- * `status --ownership` (and any future caller that wants ownership
- * without a rendered PatchLintIssue) can consume the same structured
- * data the rule itself relies on. Previously status had to parse the
- * rule's human-readable message to recover the patch list, which was
- * both fragile and made the lint message format part of an implicit
- * contract.
- *
- * @param ctx - Pre-built queue context
- */
-export declare function collectNewFileCreatorsByPath(ctx: PatchQueueContext): Map<string, string[]>;
+export { collectNewFileCreatorsByPath, invalidateNewFileCreatorsCache, } from './patch-lint-creators.js';
 /**
  * Cross-patch lint rule: the same path is newly created (`--- /dev/null →
  * +++ b/path`) by more than one patch. This is the failure mode that

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

@@ -16,7 +16,9 @@ import { readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { stripJsComments } from '../utils/regex.js';
 import { discoverPatches } from './patch-files.js';
+import { collectNewFileCreatorsByPath } from './patch-lint-creators.js';
 import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-diff.js';
+import { lintPatchQueueModuleRegistrations } from './patch-lint-module-registration.js';
 import { loadPatchesManifest } from './patch-manifest-io.js';
 import { categoryRangeForOrder, categoryRangeLabel } from './patch-policy.js';
 import { extractNewFileContent } from './patch-transform.js';
@@ -81,37 +83,11 @@ export async function buildPatchQueueContext(patchesDir, config) {
     entries.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
     return { entries, ...(config?.patchPolicy ? { patchPolicy: config.patchPolicy } : {}) };
 }
-/**
- * Returns the raw `path → patches[]` map of files created in `new file
- * mode` by at least one patch in the queue. Paths created by only one
- * patch are also included so callers can distinguish "no creator" from
- * "exactly one creator" without re-scanning the diffs.
- *
- * Split out from {@link lintPatchQueueDuplicateCreations} so
- * `status --ownership` (and any future caller that wants ownership
- * without a rendered PatchLintIssue) can consume the same structured
- * data the rule itself relies on. Previously status had to parse the
- * rule's human-readable message to recover the patch list, which was
- * both fragile and made the lint message format part of an implicit
- * contract.
- *
- * @param ctx - Pre-built queue context
- */
-export function collectNewFileCreatorsByPath(ctx) {
-    const creators = new Map();
-    for (const entry of ctx.entries) {
-        const newFiles = detectNewFilesInDiff(entry.diff);
-        for (const file of newFiles) {
-            let owners = creators.get(file);
-            if (!owners) {
-                owners = [];
-                creators.set(file, owners);
-            }
-            owners.push(entry.filename);
-        }
-    }
-    return creators;
-}
+// The creators map (split out of `lintPatchQueueDuplicateCreations` so
+// `status --ownership` can consume the structured data) lives in
+// `patch-lint-creators.ts` with its per-context memoisation (FORGE J1);
+// re-exported here so callers keep importing from `patch-lint.ts`.
+export { collectNewFileCreatorsByPath, invalidateNewFileCreatorsCache, } from './patch-lint-creators.js';
 /**
  * Cross-patch lint rule: the same path is newly created (`--- /dev/null →
  * +++ b/path`) by more than one patch. This is the failure mode that
@@ -131,6 +107,7 @@ export function lintPatchQueueDuplicateCreations(ctx) {
             issues.push({
                 file,
                 check: 'duplicate-new-file-creation',
+                patches: [...owners].sort((a, b) => a.localeCompare(b)),
                 fingerprint: `duplicate-new-file-creation|${file}|${[...owners].sort((a, b) => a.localeCompare(b)).join(',')}`,
                 message: `File "${file}" is created (new file mode) by multiple patches: ${owners.join(', ')}. ` +
                     'Only one patch may create a given path. Use "patch delete" or ' +
@@ -519,6 +496,7 @@ export function lintPatchQueueForwardImports(ctx) {
         issues.push({
             file: sitePath,
             check: 'forward-import',
+            patches: [entry.filename],
             fingerprint: `forward-import|${sitePath}|${cleaned}|${fingerprintOwners}`,
             message: `${sitePath} in ${entry.filename} imports "${specifier}", ` +
                 `but the matching new file is created by a later patch: ${ownersSummary}. ` +
@@ -537,6 +515,7 @@ export function lintPatchQueueForwardImports(ctx) {
             issues.push({
                 file: dependency.file,
                 check: 'staged-dependency-unused',
+                patches: [entry.filename],
                 fingerprint: `staged-dependency-unused|${entry.filename}|${dependency.file}|${dependency.specifier}|${dependency.creates}|${dependency.owner ?? ''}`,
                 message: `${entry.filename} declares a staged forward import from ${dependency.file} ` +
                     `to "${dependency.specifier}" / ${dependency.creates}, but that exact forward dependency was not found. ` +
@@ -559,6 +538,7 @@ export function lintPatchQueueForwardImports(ctx) {
             issues.push({
                 file: registration.file,
                 check: 'staged-dependency-unused',
+                patches: [entry.filename],
                 fingerprint: `staged-dependency-unused|${entry.filename}|${registration.file}|reg:${registration.line}|${registration.creates}|${registration.owner ?? ''}`,
                 message: `${entry.filename} declares a staged registration in ${registration.file} ` +
                     `("${registration.line}") for ${registration.creates}, but ${describeRegistrationFailure(failure)} ` +
@@ -631,5 +611,9 @@ function isRegistrationLinePresent(entry, registration) {
  *   manually for projected/hypothetical states)
  */
 export function lintPatchQueue(ctx) {
-    return [...lintPatchQueueDuplicateCreations(ctx), ...lintPatchQueueForwardImports(ctx)];
+    return [
+        ...lintPatchQueueDuplicateCreations(ctx),
+        ...lintPatchQueueForwardImports(ctx),
+        ...lintPatchQueueModuleRegistrations(ctx),
+    ];
 }

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

@@ -9,7 +9,9 @@
 import type * as acorn from 'acorn';
 import type { ClassDeclaration, FunctionDeclaration } from 'estree';
 import type { AcornESTreeNode } from './ast-utils.js';
-export type JsDocCheck = 'missing-jsdoc' | 'jsdoc-param-mismatch' | 'jsdoc-missing-returns' | 'missing-jsdoc-class-method' | 'jsdoc-class-method-param-mismatch' | 'jsdoc-class-method-missing-returns';
+export type JsDocCheck = 
+/** The source could not be parsed, so no JSDoc rule could run on it. */
+'jsdoc-unparseable-source' | 'missing-jsdoc' | 'jsdoc-param-mismatch' | 'jsdoc-missing-returns' | 'missing-jsdoc-class-method' | 'jsdoc-class-method-param-mismatch' | 'jsdoc-class-method-missing-returns';
 export interface JsDocIssue {
     line: number;
     check: JsDocCheck;

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

@@ -7,7 +7,8 @@
  * Separated from `patch-lint.ts` to keep both files within the
  * project's per-file line budget.
  */
-import { parseModule } from './ast-utils.js';
+import { toError } from '../utils/errors.js';
+import { asEstree, parseModule } from './ast-utils.js';
 // ---------------------------------------------------------------------------
 // JSDoc comment helpers
 // ---------------------------------------------------------------------------
@@ -339,7 +340,7 @@ export function validateClassMethods(cls, comments, source, issues, severity) {
     for (const member of cls.body.body) {
         if (member.type !== 'MethodDefinition')
             continue;
-        const method = member;
+        const method = asEstree(member);
         if (isPrivateMethodKey(method))
             continue;
         const name = staticMethodName(method);
@@ -369,7 +370,7 @@ export function validateClassMethods(cls, comments, source, issues, severity) {
             continue;
         }
         const skipReturns = method.kind === 'constructor' || method.kind === 'set';
-        validateParamsAndReturns(method.value, jsDoc, issues, {
+        validateParamsAndReturns(asEstree(method.value), jsDoc, issues, {
             label,
             line,
             paramCheck: 'jsdoc-class-method-param-mismatch',
@@ -396,8 +397,17 @@ export function validateExportJsDoc(source, options) {
     try {
         ast = parseModule(source, comments);
     }
-    catch {
-        return [];
+    catch (error) {
+        // An unparseable source is NOT a clean file. Returning `[]` here was the
+        // same value as "fully documented", so a syntax error silently cleared
+        // every rule this module enforces. Report it instead.
+        return [
+            {
+                line: 1,
+                check: 'jsdoc-unparseable-source',
+                message: `Source could not be parsed for JSDoc analysis: ${toError(error).message}`,
+            },
+        ];
     }
     const issues = [];
     const body = ast.body;

package/dist/src/core/patch-lint-module-registration.d.ts

@@ -0,0 +1,15 @@
+import type { PatchLintIssue } from '../types/commands/index.js';
+interface ModuleRegistrationQueueEntry {
+    filename: string;
+    newFiles: ReadonlyMap<string, string>;
+    modifiedFileAdditions: ReadonlyMap<string, string>;
+}
+interface ModuleRegistrationQueueContext {
+    entries: readonly ModuleRegistrationQueueEntry[];
+}
+/**
+ * Flags a new `.sys.mjs` imported through a Firefox resource URL when the
+ * projected queue never adds it to a moz.build list.
+ */
+export declare function lintPatchQueueModuleRegistrations(ctx: ModuleRegistrationQueueContext): PatchLintIssue[];
+export {};

package/dist/src/core/patch-lint-module-registration.js

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Queue-wide registration lint for newly-created Firefox system modules.
+ */
+import { basename } from 'node:path';
+import { escapeRegex, stripJsComments } from '../utils/regex.js';
+const IMPORTABLE_EXTENSIONS = ['.mjs', '.sys.mjs', '.js', '.jsm'];
+/** Maps Firefox's common system-module resource URLs to their source suffix. */
+function moduleSourceSuffix(specifier) {
+    const cleaned = specifier.split(/[?#]/)[0] ?? specifier;
+    for (const prefix of ['resource:///modules/', 'resource://gre/modules/']) {
+        if (cleaned.startsWith(prefix))
+            return `/modules/${cleaned.slice(prefix.length)}`;
+    }
+    return undefined;
+}
+/** Resource-module strings in actual code (comments removed), de-duplicated. */
+function extractResourceModuleSpecifiers(content) {
+    const stripped = stripJsComments(content);
+    const found = new Set();
+    const pattern = /["'](resource:\/\/(?:\/|gre\/)modules\/[^"']+\.sys\.mjs(?:[?#][^"']*)?)["']/g;
+    for (const match of stripped.matchAll(pattern)) {
+        if (match[1] !== undefined)
+            found.add(match[1]);
+    }
+    return [...found];
+}
+/** True when some patch in the projected queue adds the module to moz.build. */
+function queueRegistersModule(ctx, leaf) {
+    const escaped = escapeRegex(leaf);
+    const quotedLeaf = new RegExp(`["']${escaped}["']`);
+    for (const entry of ctx.entries) {
+        for (const [path, content] of [...entry.newFiles, ...entry.modifiedFileAdditions]) {
+            if ((path === 'moz.build' || path.endsWith('/moz.build')) && quotedLeaf.test(content)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Flags a new `.sys.mjs` imported through a Firefox resource URL when the
+ * projected queue never adds it to a moz.build list.
+ */
+export function lintPatchQueueModuleRegistrations(ctx) {
+    const imported = new Map();
+    const collect = (entry, path, content) => {
+        if (!IMPORTABLE_EXTENSIONS.some((extension) => path.endsWith(extension)))
+            return;
+        for (const specifier of extractResourceModuleSpecifiers(content)) {
+            const suffix = moduleSourceSuffix(specifier);
+            if (suffix === undefined)
+                continue;
+            const importers = imported.get(suffix) ?? new Set();
+            importers.add(entry.filename);
+            imported.set(suffix, importers);
+        }
+    };
+    for (const entry of ctx.entries) {
+        for (const [path, content] of entry.newFiles)
+            collect(entry, path, content);
+        for (const [path, content] of entry.modifiedFileAdditions)
+            collect(entry, path, content);
+    }
+    const issues = [];
+    for (const entry of ctx.entries) {
+        for (const path of entry.newFiles.keys()) {
+            if (!path.endsWith('.sys.mjs'))
+                continue;
+            const matched = [...imported.entries()].find(([suffix]) => path.endsWith(suffix));
+            if (!matched || queueRegistersModule(ctx, basename(path)))
+                continue;
+            const [suffix, importers] = matched;
+            issues.push({
+                file: path,
+                check: 'unregistered-system-module',
+                patches: [...new Set([entry.filename, ...importers])],
+                fingerprint: `unregistered-system-module|${path}|${suffix}`,
+                message: `${path} is newly created and imported as a resource module, but no patch adds ` +
+                    `${basename(path)} to a moz.build list. Register it in EXTRA_JS_MODULES (or the ` +
+                    'appropriate namespaced list) before export; source-level typechecks can resolve the ' +
+                    'file even though the packaged browser cannot.',
+                severity: 'error',
+            });
+        }
+    }
+    return issues;
+}

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

@@ -31,40 +31,128 @@ const STRICT_ORDERED_MOZBUILD_LISTS = [
     'XPIDL_SOURCES',
 ];
 const LIST_OPENER = new RegExp(`^\\s*((?:${STRICT_ORDERED_MOZBUILD_LISTS.join('|')})(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)\\s*\\+?=\\s*\\[`);
-/** Extracts every strict-ordered list (with items in file order) from moz.build content. */
+/**
+ * Strips a Python trailing comment from a moz.build line.
+ *
+ * `#` inside a quoted string is not a comment, so the scan tracks quote state
+ * rather than using `indexOf('#')`.
+ */
+/**
+ * True when `line` contains a `]` outside any quoted span. A bracket inside an
+ * item (`"icons[2x].png"`) is filename text, not the list's close — reading it
+ * as one truncated the item set and left every later item unchecked.
+ */
+function hasUnquotedCloseBracket(line) {
+    let quote;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (quote !== undefined) {
+            if (ch === '\\')
+                i += 1;
+            else if (ch === quote)
+                quote = undefined;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (ch === ']') {
+            return true;
+        }
+    }
+    return false;
+}
+function stripMozBuildComment(line) {
+    let quote;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (quote !== undefined) {
+            if (ch === '\\')
+                i += 1;
+            else if (ch === quote)
+                quote = undefined;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (ch === '#') {
+            return line.slice(0, i);
+        }
+    }
+    return line;
+}
+/**
+ * Extracts every strict-ordered list (with items in file order) from moz.build
+ * content.
+ *
+ * Comments are stripped before both the item scan and the close-bracket test.
+ * moz.build is Python, and before 0.41.0 neither step knew that:
+ *
+ * - a quoted string in a trailing comment was scraped in as a phantom list
+ *   item (`"Zeta.cpp",  # replaces "Beta.cpp"` yielded a `Beta.cpp` entry), so
+ *   the sort check reported an unsorted list naming a file that is not in it —
+ *   with a fingerprint that could never stabilise, because the item does not
+ *   exist to be moved;
+ * - a `]` anywhere in a comment (`# see foo[0]`) closed the list early and
+ *   silently truncated the item set.
+ *
+ * The scan also no longer advances the caller's loop counter: an unterminated
+ * list used to consume the rest of the file, so every *later* list in it was
+ * skipped entirely.
+ *
+ * Nor does an unterminated list borrow the NEXT list's bracket. The forward
+ * scan stops at the next list opener rather than reading through it: without
+ * that, an unclosed `EXTRA_COMPONENTS` swallowed the following
+ * `EXTRA_JS_MODULES` — its items merged into the first list's item set and its
+ * `]` accepted as the first list's close — reporting a sorting error against a
+ * variable that never contained those items, and skipping the second list.
+ */
 function collectStrictOrderedLists(content) {
     const lines = content.split('\n');
     const occurrences = [];
     for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        const opener = LIST_OPENER.exec(line);
+        const opener = LIST_OPENER.exec(lines[i] ?? '');
         if (!opener)
             continue;
         const varName = opener[1] ?? '';
         const items = [];
         // Items may start on the opener line (`VAR += ["a", "b"]`) or span
         // following lines until the closing bracket.
-        let rest = line.slice(opener[0].length);
+        let rest = stripMozBuildComment((lines[i] ?? '').slice(opener[0].length));
         let closed = false;
+        // Scan ahead on a local cursor so an unterminated list costs only itself.
+        let cursor = i;
         for (;;) {
-            for (const quoted of rest.matchAll(/["']([^"']+)["']/g)) {
-                items.push(quoted[1] ?? '');
+            // Quote types are matched pairwise so an apostrophe inside a
+            // double-quoted item ("don't.cpp") cannot terminate the match early and
+            // scrape in a phantom item.
+            for (const quoted of rest.matchAll(/"([^"]+)"|'([^']+)'/g)) {
+                items.push(quoted[1] ?? quoted[2] ?? '');
             }
-            if (/\]/.test(rest)) {
+            if (hasUnquotedCloseBracket(rest)) {
                 closed = true;
                 break;
             }
-            i += 1;
-            if (i >= lines.length)
+            cursor += 1;
+            if (cursor >= lines.length)
                 break;
-            rest = lines[i] ?? '';
+            rest = stripMozBuildComment(lines[cursor] ?? '');
+            if (LIST_OPENER.test(rest)) {
+                // A new list starts here, so the previous one never closed. Rewind so
+                // the outer loop examines this line as its own opener.
+                cursor -= 1;
+                break;
+            }
             if (/^\s*\]/.test(rest)) {
                 closed = true;
                 break;
             }
         }
-        if (closed)
+        if (closed) {
             occurrences.push({ varName, items });
+            // Resume after the list we just consumed; a list that never closed
+            // leaves `i` untouched so the next line is still examined.
+            i = cursor;
+        }
     }
     return occurrences;
 }