@hominis/fireforge 0.49.2 → 0.51.0

package/dist/src/core/patch-export.js

@@ -2,12 +2,13 @@
 import { join } from 'node:path';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
+import { info, warn } from '../utils/logger.js';
 import { discoverPatches, withPatchDirectoryLock } from './patch-apply.js';
 import { findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { addPatchToManifest, loadPatchesManifestForWrite, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
 import { formatPatchOrder, requirePatchOrder } from './patch-parse.js';
 import { allocatePolicyOrder, enforcePatchPolicy } from './patch-policy.js';
+import { manifestWithRetiredSlots, reservationAt, reservedOrderSet } from './patch-retired.js';
 export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { escapeRegex } from '../utils/regex.js';
 export { mutatePatchMetadata, updatePatchMetadata } from './patch-export-metadata.js';
@@ -39,18 +40,16 @@ export function buildPlanExportInput(input) {
 /**
  * Gets the next patch number for a new patch.
  * @param patchesDir - Path to the patches directory
+ * @param reserved - Orders held by `patch reserve`, skipped
  * @returns Next patch number (e.g., "005" for 4 existing patches)
  */
-export async function getNextPatchNumber(patchesDir) {
+export async function getNextPatchNumber(patchesDir, reserved = new Set()) {
     const patches = await discoverPatches(patchesDir);
-    if (patches.length === 0) {
-        return '001';
-    }
     const finitePatches = patches.filter((p) => Number.isFinite(p.order));
-    if (finitePatches.length === 0)
-        return '001';
     const maxOrder = finitePatches.reduce((max, p) => Math.max(max, p.order), 0);
-    const nextNumber = maxOrder + 1;
+    let nextNumber = maxOrder + 1;
+    while (reserved.has(nextNumber))
+        nextNumber++;
     return String(nextNumber).padStart(Math.max(3, String(nextNumber).length), '0');
 }
 /**
@@ -117,8 +116,8 @@ export function patchNameSlug(name, category) {
  * @param name - Human-readable name
  * @returns Filename like "001-ui-sidebar.patch"
  */
-export async function getNextPatchFilename(patchesDir, category, name) {
-    const patchNumber = await getNextPatchNumber(patchesDir);
+export async function getNextPatchFilename(patchesDir, category, name, reserved = new Set()) {
+    const patchNumber = await getNextPatchNumber(patchesDir, reserved);
     const sanitizedName = patchNameSlug(name, category);
     return `${patchNumber}-${category}-${sanitizedName}.patch`;
 }
@@ -233,12 +232,15 @@ async function computeExportPlanUnderLock(input) {
     // wipes the queue metadata, and the rollback path would then delete
     // patches.json entirely because manifestBefore looked absent.
     const manifestBefore = await loadPatchesManifestForWrite(input.patchesDir);
+    // A default allocation never lands on a reservation; only an explicit
+    // `--order` placement fills one.
+    const reserved = reservedOrderSet(manifestBefore ?? {});
     const policyOrder = input.config !== undefined
-        ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category)
+        ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category, reserved)
         : null;
     const patchFilename = policyOrder !== null
         ? `${formatPatchOrder(policyOrder)}-${input.category}-${patchNameSlug(input.name, input.category)}.patch`
-        : await getNextPatchFilename(input.patchesDir, input.category, input.name);
+        : await getNextPatchFilename(input.patchesDir, input.category, input.name, reserved);
     const patchPath = join(input.patchesDir, patchFilename);
     const metadata = {
         filename: patchFilename,
@@ -266,6 +268,12 @@ async function computeExportPlanUnderLock(input) {
     const afterPatches = (manifestBefore?.patches ?? []).filter((p) => !supersededSet.has(p.filename) && p.filename !== patchFilename);
     afterPatches.push(metadata);
     afterPatches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
+    const reservation = reservationAt(manifestBefore, metadata.order);
+    if (reservation !== undefined) {
+        info(`Order ${formatPatchOrder(metadata.order)} was reserved by ${reservation.owner}` +
+            `${reservation.reason !== undefined ? ` (${reservation.reason})` : ''}; ` +
+            'this export fills the reservation.');
+    }
     return {
         patchFilename,
         patchPath,
@@ -273,10 +281,8 @@ async function computeExportPlanUnderLock(input) {
         supersededDetails,
         supersededPatches,
         manifestBefore: manifestBefore ?? null,
-        manifestAfter: {
-            version: 1,
-            patches: afterPatches,
-        },
+        // A patch landing on a retired or reserved order fills that slot.
+        manifestAfter: manifestWithRetiredSlots(manifestBefore, afterPatches),
     };
 }
 /**

package/dist/src/core/patch-files.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { readdir } from 'node:fs/promises';
+import { readdir, stat } from 'node:fs/promises';
 import { extname, join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
 import { extractAffectedFiles, extractOrder } from './patch-parse.js';
@@ -9,16 +9,34 @@ export async function discoverPatches(patchesDir) {
         return [];
     }
     const entries = await readdir(patchesDir, { withFileTypes: true });
-    const patches = entries
-        .filter((entry) => entry.isFile() && extname(entry.name) === '.patch')
-        .map((entry) => ({
-        path: join(patchesDir, entry.name),
-        filename: entry.name,
-        order: extractOrder(entry.name),
-    }));
+    const patches = [];
+    for (const entry of entries) {
+        if (extname(entry.name) !== '.patch')
+            continue;
+        // A symlinked patch (a scratch queue built from links to the real
+        // patches) counts when it resolves to a regular file; a dangling link or
+        // a link to a directory does not.
+        if (!entry.isFile() &&
+            !(entry.isSymbolicLink() && (await isLinkToFile(patchesDir, entry.name)))) {
+            continue;
+        }
+        patches.push({
+            path: join(patchesDir, entry.name),
+            filename: entry.name,
+            order: extractOrder(entry.name),
+        });
+    }
     patches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
     return patches;
 }
+async function isLinkToFile(dir, name) {
+    try {
+        return (await stat(join(dir, name))).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 /** Counts the patch files currently present in a patch directory. */
 export async function countPatches(patchesDir) {
     const patches = await discoverPatches(patchesDir);

package/dist/src/core/patch-lint-checkjs-any-import.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Explains an implicit-`any` checkJs finding that comes from a URL import
+ * the per-patch program cannot resolve.
+ *
+ * The program resolves URL imports only to modules the queue creates (for
+ * a test, those created up to its own patch, plus its directory's
+ * head.js), so a `resource:///` or `chrome://` import of a module a later
+ * patch creates, an upstream module, or a basename two patches create
+ * falls back to the shim's `declare module 'resource:*'` wildcard and
+ * types as `any`. A callback
+ * over its values then has implicitly-`any` parameters under
+ * `checkJsStrict`, while the whole-tree `fireforge typecheck`, which sees
+ * the module, is clean. Without the note the two disagree with no
+ * explanation. Split out of patch-lint-checkjs.ts for the line budget.
+ */
+/** Unresolved URL import specifiers, keyed by the importing file's TS path. */
+export type AnyTypedImports = Map<string, Set<string>>;
+/**
+ * The note an implicit-`any` finding carries when its file imports a
+ * `resource://`/`chrome://` module this checkJs program could not resolve.
+ * Such an import types as `any` (the shim's wildcard module), so a
+ * callback over its values has implicitly-`any` parameters here while the
+ * whole-tree `fireforge typecheck`, which sees the module, is clean.
+ */
+export declare function anyTypedImportHint(code: number, specifiers: ReadonlySet<string> | undefined): string;
+/**
+ * The host's `resolveModuleNameLiterals`: owned specifiers first, then a
+ * reviewed `paths` mapping, recording every URL import that resolves to
+ * neither.
+ *
+ * @param resolveOwned - Patch-owned specifier resolver
+ * @param resolveViaPaths - Optional `paths` resolver
+ * @param into - Map that collects the unresolved URL imports
+ */
+export declare function createModuleLiteralResolver<Resolved>(resolveOwned: (specifier: string) => Resolved | undefined, resolveViaPaths: ((specifier: string) => Resolved | undefined) | undefined, into: AnyTypedImports): (moduleLiterals: readonly {
+    text: string;
+}[], containingFile: string) => Array<{
+    resolvedModule: Resolved | undefined;
+}>;

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

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Explains an implicit-`any` checkJs finding that comes from a URL import
+ * the per-patch program cannot resolve.
+ *
+ * The program resolves URL imports only to modules the queue creates (for
+ * a test, those created up to its own patch, plus its directory's
+ * head.js), so a `resource:///` or `chrome://` import of a module a later
+ * patch creates, an upstream module, or a basename two patches create
+ * falls back to the shim's `declare module 'resource:*'` wildcard and
+ * types as `any`. A callback
+ * over its values then has implicitly-`any` parameters under
+ * `checkJsStrict`, while the whole-tree `fireforge typecheck`, which sees
+ * the module, is clean. Without the note the two disagree with no
+ * explanation. Split out of patch-lint-checkjs.ts for the line budget.
+ */
+/** TypeScript's implicit-`any` diagnostic codes (noImplicitAny). */
+const IMPLICIT_ANY_CODES = new Set([
+    7005, 7006, 7008, 7010, 7011, 7019, 7031, 7034,
+]);
+function recordAnyTypedImport(into, containingFile, specifier) {
+    if (!/^(?:resource|chrome):/.test(specifier))
+        return;
+    const list = into.get(containingFile) ?? new Set();
+    list.add(specifier);
+    into.set(containingFile, list);
+}
+/**
+ * The note an implicit-`any` finding carries when its file imports a
+ * `resource://`/`chrome://` module this checkJs program could not resolve.
+ * Such an import types as `any` (the shim's wildcard module), so a
+ * callback over its values has implicitly-`any` parameters here while the
+ * whole-tree `fireforge typecheck`, which sees the module, is clean.
+ */
+export function anyTypedImportHint(code, specifiers) {
+    if (!IMPLICIT_ANY_CODES.has(code) || specifiers === undefined || specifiers.size === 0)
+        return '';
+    const list = [...specifiers].sort().join(', ');
+    return (` (This file imports ${list}, which this per-patch checkJs program cannot resolve — ` +
+        'no patch up to this one creates the module under that name: a later patch creates it, ' +
+        'it is upstream, or two patches create the same basename — so the import is typed `any`. ' +
+        'Annotate the parameter explicitly; the whole-tree "fireforge typecheck" resolves the real type.)');
+}
+/**
+ * The host's `resolveModuleNameLiterals`: owned specifiers first, then a
+ * reviewed `paths` mapping, recording every URL import that resolves to
+ * neither.
+ *
+ * @param resolveOwned - Patch-owned specifier resolver
+ * @param resolveViaPaths - Optional `paths` resolver
+ * @param into - Map that collects the unresolved URL imports
+ */
+export function createModuleLiteralResolver(resolveOwned, resolveViaPaths, into) {
+    return (moduleLiterals, containingFile) => moduleLiterals.map((literal) => {
+        const owned = resolveOwned(literal.text);
+        if (owned)
+            return { resolvedModule: owned };
+        const viaPaths = resolveViaPaths?.(literal.text);
+        if (viaPaths === undefined)
+            recordAnyTypedImport(into, containingFile, literal.text);
+        return { resolvedModule: viaPaths };
+    });
+}

package/dist/src/core/patch-lint-checkjs-diagnostics.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Collects a checkJs program's diagnostics, for every file or for a report
+ * scope only. A per-test program resolves the modules its imports reach
+ * (see `runCheckJsTestFilesGrouped`), and asking for the whole program's
+ * diagnostics would type-check each of those modules once per test, so a
+ * scoped run asks only for the files it reports. Split out of
+ * patch-lint-checkjs.ts for the line budget.
+ */
+/**
+ * The program's semantic and syntactic diagnostics, limited to the files
+ * `reportOnly` names when it is set.
+ *
+ * @param program - The built program
+ * @param relByAbsolute - Owned files: TS path → repo-relative path
+ * @param reportOnly - Repo-relative files to collect for, or all when unset
+ */
+export declare function collectCheckJsDiagnostics(program: import('typescript').Program, relByAbsolute: ReadonlyMap<string, string>, reportOnly: ReadonlySet<string> | undefined): import('typescript').Diagnostic[];

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

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Collects a checkJs program's diagnostics, for every file or for a report
+ * scope only. A per-test program resolves the modules its imports reach
+ * (see `runCheckJsTestFilesGrouped`), and asking for the whole program's
+ * diagnostics would type-check each of those modules once per test, so a
+ * scoped run asks only for the files it reports. Split out of
+ * patch-lint-checkjs.ts for the line budget.
+ */
+/**
+ * The program's semantic and syntactic diagnostics, limited to the files
+ * `reportOnly` names when it is set.
+ *
+ * @param program - The built program
+ * @param relByAbsolute - Owned files: TS path → repo-relative path
+ * @param reportOnly - Repo-relative files to collect for, or all when unset
+ */
+export function collectCheckJsDiagnostics(program, relByAbsolute, reportOnly) {
+    if (reportOnly === undefined) {
+        return [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()];
+    }
+    return program
+        .getSourceFiles()
+        .filter((sourceFile) => {
+        const rel = relByAbsolute.get(sourceFile.fileName);
+        return rel !== undefined && reportOnly.has(rel);
+    })
+        .flatMap((sourceFile) => [
+        ...program.getSemanticDiagnostics(sourceFile),
+        ...program.getSyntacticDiagnostics(sourceFile),
+    ]);
+}

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

@@ -82,6 +82,8 @@ export interface RunCheckJsGroupedInput {
      * compiler options and shim in one run. See {@link runCheckJsTestFilesGrouped}.
      */
     sourceFileCache?: CheckJsSourceFileCache;
+    /** When set, diagnostics are collected only for these repo-relative files. */
+    reportOnly?: ReadonlySet<string>;
 }
 /**
  * Builds the checkJs program once over `resolutionOwned` and returns its
@@ -136,12 +138,19 @@ export declare function invokePatchLintCheckJs(repoDir: string, patchOwnedFiles:
  * reported per program (head helpers report from their own program), and
  * run-level errors are de-duplicated across programs.
  *
+ * With `resolvableModules`, a test's `resource:///` and `chrome://`
+ * imports also resolve to the modules it returns for that test (the
+ * modules the queue creates up to the test's own patch), so a test that
+ * imports an earlier patch's module is typed against its real source
+ * instead of the shim's `any` wildcard. Those modules are resolution
+ * targets only: never roots, and never reported on.
+ *
  * @param repoDir - Absolute engine (repository) directory
  * @param testFiles - Patch-owned test-script paths (repo-relative)
  * @param patchLint - The resolved `patchLint` config block
  * @param projectRoot - FireForge project root for shim resolution
  */
-export declare function runCheckJsTestFilesGrouped(repoDir: string, testFiles: Set<string>, patchLint: PatchLintConfig, projectRoot: string, rootScope?: ReadonlySet<string>): Promise<GroupedCheckJsResult>;
+export declare function runCheckJsTestFilesGrouped(repoDir: string, testFiles: Set<string>, patchLint: PatchLintConfig, projectRoot: string, rootScope?: ReadonlySet<string>, resolvableModules?: (testFile: string) => ReadonlySet<string>): Promise<GroupedCheckJsResult>;
 /**
  * Grouped variant of {@link invokePatchLintCheckJs}: builds one queue-wide
  * checkJs program over `patchOwnedFiles` and returns its findings grouped by

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

@@ -31,7 +31,9 @@ import { pathExists } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { normalizePathSlashes } from '../utils/paths.js';
 import { withGeckoDomTypes } from './gecko-dom-types.js';
+import { anyTypedImportHint, createModuleLiteralResolver, } from './patch-lint-checkjs-any-import.js';
 import { withSharedSourceFiles } from './patch-lint-checkjs-cache.js';
+import { collectCheckJsDiagnostics } from './patch-lint-checkjs-diagnostics.js';
 import { collectUnmanagedCompanions, retargetUnmanagedCompanionHints, } from './patch-lint-unmanaged-companion.js';
 import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES, TEST_HARNESS_SHIM, UNDEFINED_IDENTIFIER_CODES, UNDEFINED_IDENTIFIER_HINT, } from './typecheck-shim.js';
 // ---------------------------------------------------------------------------
@@ -293,6 +295,9 @@ export async function runCheckJsGrouped(input) {
         ...overrides,
     };
     const resolveOwnedSpecifier = createOwnedSpecifierResolver(ts, ownedAbsolute);
+    // URL imports this program cannot resolve, per importing file (see
+    // patch-lint-checkjs-any-import.ts).
+    const anyTypedImports = new Map();
     // Custom compiler host: reads patch-owned files from disk, returns
     // the shim for the shim path, and returns empty content for
     // anything else to avoid reading the full Firefox tree.
@@ -333,17 +338,10 @@ export async function runCheckJsGrouped(input) {
                 return shimSource;
             return defaultHost.readFile(fileName);
         },
-        resolveModuleNameLiterals(moduleLiterals) {
-            return moduleLiterals.map((literal) => {
-                const owned = resolveOwnedSpecifier(literal.text);
-                if (owned)
-                    return { resolvedModule: owned };
-                return { resolvedModule: resolveViaPaths?.(literal.text) };
-            });
-        },
+        resolveModuleNameLiterals: createModuleLiteralResolver(resolveOwnedSpecifier, resolveViaPaths, anyTypedImports),
     };
     const program = ts.createProgram(rootFiles, options, withSharedSourceFiles(host, input.sourceFileCache, shimPath, shimSource));
-    const byFile = groupOwnedDiagnostics(ts, [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()], relByAbsolute, input.mode?.undefinedIdentifiers ?? 'warning');
+    const byFile = groupOwnedDiagnostics(ts, collectCheckJsDiagnostics(program, relByAbsolute, input.reportOnly), relByAbsolute, input.mode?.undefinedIdentifiers ?? 'warning', anyTypedImports);
     verbose(`checkJs: analyzed ${rootFiles.length - 1} file(s) across ${byFile.size} owning file(s)`);
     return { byFile, global: [] };
 }
@@ -354,7 +352,7 @@ export async function runCheckJsGrouped(input) {
  * or shim files are dropped. Only owned files (in `relByAbsolute`) carry
  * findings.
  */
-function groupOwnedDiagnostics(ts, diagnostics, relByAbsolute, undefinedIdentifiers = 'warning') {
+function groupOwnedDiagnostics(ts, diagnostics, relByAbsolute, undefinedIdentifiers = 'warning', anyTypedImports = new Map()) {
     const byFile = new Map();
     for (const diag of diagnostics) {
         if (SUPPRESSED_DIAGNOSTIC_CODES.has(diag.code))
@@ -386,7 +384,7 @@ function groupOwnedDiagnostics(ts, diagnostics, relByAbsolute, undefinedIdentifi
             check: 'checkjs-type-error',
             message: isUndefinedIdentifier
                 ? `Line ${line}: ${messageText} ${UNDEFINED_IDENTIFIER_HINT}`
-                : `Line ${line}: ${messageText}`,
+                : `Line ${line}: ${messageText}${anyTypedImportHint(diag.code, anyTypedImports.get(sourceFile.fileName))}`,
             severity,
         });
         byFile.set(relPath, bucket);
@@ -451,12 +449,19 @@ export async function invokePatchLintCheckJs(repoDir, patchOwnedFiles, patchLint
  * reported per program (head helpers report from their own program), and
  * run-level errors are de-duplicated across programs.
  *
+ * With `resolvableModules`, a test's `resource:///` and `chrome://`
+ * imports also resolve to the modules it returns for that test (the
+ * modules the queue creates up to the test's own patch), so a test that
+ * imports an earlier patch's module is typed against its real source
+ * instead of the shim's `any` wildcard. Those modules are resolution
+ * targets only: never roots, and never reported on.
+ *
  * @param repoDir - Absolute engine (repository) directory
  * @param testFiles - Patch-owned test-script paths (repo-relative)
  * @param patchLint - The resolved `patchLint` config block
  * @param projectRoot - FireForge project root for shim resolution
  */
-export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint, projectRoot, rootScope) {
+export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint, projectRoot, rootScope, resolvableModules) {
     const merged = { byFile: new Map(), global: [] };
     if (testFiles.size === 0)
         return merged;
@@ -487,7 +492,9 @@ export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint,
         }
         const result = await runCheckJsGrouped({
             repoDir,
-            resolutionOwned: roots,
+            resolutionOwned: new Set([...roots, ...(resolvableModules?.(file) ?? [])]),
+            rootScope: roots,
+            reportOnly: new Set([file]),
             ...(patchLint.checkJsTestShim !== undefined
                 ? { extraShimPath: patchLint.checkJsTestShim }
                 : {}),

package/dist/src/core/patch-lint-code-lines.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Line counting for the size rules: raw lines, code lines, and the per-line
+ * code mask the `addedCode` patch-size metric reads off a file's
+ * post-image.
+ *
+ * "Code" means a line left non-blank once comments are blanked. JS goes
+ * through acorn's tokenizer (`stripJsCommentsParsed`), so a regex literal
+ * containing `/*`, a string containing `//`, nested template literals,
+ * JSDoc and a shebang are all judged correctly, and a blank line inside a
+ * template literal counts as blank.
+ */
+/**
+ * Counts the lines of `content` the way `wc -l` reports them. A naive
+ * `split('\n').length` over-counts by one for any content ending in `\n`
+ * (the common case), making the size rules fire one line early against
+ * the operator's own `wc -l` measurement.
+ */
+export declare function countRawLines(content: string): number;
+/** The result of {@link countCodeLines}. */
+export interface CodeLineCount {
+    /**
+     * Lines that carry code: non-blank once comments are blanked. When the
+     * source could not be tokenized this is the raw line count instead, the
+     * upper bound, so an unparsable file never measures smaller than it is.
+     */
+    lines: number;
+    /** False when acorn could tokenize the source neither as a module nor as a script. */
+    parsed: boolean;
+}
+/**
+ * Counts the code lines of a JS source: comments are blanked by acorn's
+ * tokenizer (module goal first, then script, since chrome subscripts are
+ * scripts) and the non-blank lines are counted. When neither goal
+ * tokenizes, the raw line count is returned with `parsed: false`. A regex
+ * fallback would under-count, which fails open.
+ *
+ * @param content - JS source text
+ */
+export declare function countCodeLines(content: string): CodeLineCount;
+/** The per-line code mask of one post-image. */
+export interface CodeLineMask {
+    /** `code[i]` is true when line `i + 1` carries code. */
+    code: boolean[];
+    /** False for a JS file acorn could not tokenize; every non-blank line then counts. */
+    parsed: boolean;
+}
+/**
+ * Classifies every line of a file's post-image as code or not, by file
+ * kind: JS through acorn, CSS block comments, `<!-- -->` in markup, and
+ * whole-line `#` comments (`;` for `.ini`/`.in`, `!` for `.properties`) in
+ * Fluent, manifests, `moz.build` and similar. Any other file counts every
+ * non-blank line. In CSS, lines inside a Furnace fragment expansion
+ * (`@fireforge-include` … `@fireforge-end-include`) are not code of this
+ * file: they are a copy of a shared fragment.
+ *
+ * @param file - Engine-relative path, used only to pick the file kind
+ * @param content - The post-image text
+ */
+export declare function codeLineMask(file: string, content: string): CodeLineMask;

package/dist/src/core/patch-lint-code-lines.js

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Line counting for the size rules: raw lines, code lines, and the per-line
+ * code mask the `addedCode` patch-size metric reads off a file's
+ * post-image.
+ *
+ * "Code" means a line left non-blank once comments are blanked. JS goes
+ * through acorn's tokenizer (`stripJsCommentsParsed`), so a regex literal
+ * containing `/*`, a string containing `//`, nested template literals,
+ * JSDoc and a shebang are all judged correctly, and a blank line inside a
+ * template literal counts as blank.
+ */
+import { stripJsCommentsParsed } from '../utils/regex.js';
+import { expandedFragmentLineMask } from './furnace-css-fragments.js';
+import { maskCssComments } from './patch-lint-css.js';
+/**
+ * Splits content into lines the way `wc -l` reports them: a trailing
+ * newline terminates the last line rather than starting an empty extra one.
+ */
+function splitContentLines(content) {
+    const lines = content.split('\n');
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+}
+/**
+ * Counts the lines of `content` the way `wc -l` reports them. A naive
+ * `split('\n').length` over-counts by one for any content ending in `\n`
+ * (the common case), making the size rules fire one line early against
+ * the operator's own `wc -l` measurement.
+ */
+export function countRawLines(content) {
+    return splitContentLines(content).length;
+}
+const isBlank = (line) => line.trim() === '';
+/**
+ * Counts the code lines of a JS source: comments are blanked by acorn's
+ * tokenizer (module goal first, then script, since chrome subscripts are
+ * scripts) and the non-blank lines are counted. When neither goal
+ * tokenizes, the raw line count is returned with `parsed: false`. A regex
+ * fallback would under-count, which fails open.
+ *
+ * @param content - JS source text
+ */
+export function countCodeLines(content) {
+    const stripped = stripJsCommentsParsed(content);
+    if (stripped === null)
+        return { lines: countRawLines(content), parsed: false };
+    return {
+        lines: splitContentLines(stripped).filter((line) => !isBlank(line)).length,
+        parsed: true,
+    };
+}
+const JS_FILE = /\.(?:m?js|jsm|cjs)$/;
+const MARKUP_FILE = /\.(?:x?html|xml|svg|xul|dtd)$/;
+const HASH_COMMENT_FILE = /(?:\.(?:ftl|properties|toml|ini|mn|build|py|conf|configure|sh|ya?ml|in|cfg|mozbuild)|(?:^|\/)(?:Makefile|mozconfig))$/;
+/** Line-comment leaders per hash-comment file kind. */
+function lineCommentPattern(file) {
+    if (/\.(?:ini|in)$/.test(file))
+        return /^\s*[#;]/;
+    if (file.endsWith('.properties'))
+        return /^\s*[#!]/;
+    return /^\s*#/;
+}
+/** Masks `<!-- … -->` comments, keeping newlines. Unclosed comments run to EOF. */
+function maskMarkupComments(source) {
+    return source.replace(/<!--[\s\S]*?(?:-->|$)/g, (m) => m.replace(/[^\n]/g, ' '));
+}
+/**
+ * Classifies every line of a file's post-image as code or not, by file
+ * kind: JS through acorn, CSS block comments, `<!-- -->` in markup, and
+ * whole-line `#` comments (`;` for `.ini`/`.in`, `!` for `.properties`) in
+ * Fluent, manifests, `moz.build` and similar. Any other file counts every
+ * non-blank line. In CSS, lines inside a Furnace fragment expansion
+ * (`@fireforge-include` … `@fireforge-end-include`) are not code of this
+ * file: they are a copy of a shared fragment.
+ *
+ * @param file - Engine-relative path, used only to pick the file kind
+ * @param content - The post-image text
+ */
+export function codeLineMask(file, content) {
+    if (JS_FILE.test(file)) {
+        const stripped = stripJsCommentsParsed(content);
+        const source = stripped ?? content;
+        return { code: source.split('\n').map((line) => !isBlank(line)), parsed: stripped !== null };
+    }
+    if (file.endsWith('.css')) {
+        const inFragment = expandedFragmentLineMask(content);
+        const code = maskCssComments(content)
+            .split('\n')
+            .map((line, i) => !isBlank(line) && inFragment[i] !== true);
+        return { code, parsed: true };
+    }
+    if (MARKUP_FILE.test(file)) {
+        return {
+            code: maskMarkupComments(content)
+                .split('\n')
+                .map((l) => !isBlank(l)),
+            parsed: true,
+        };
+    }
+    const comment = HASH_COMMENT_FILE.test(file) ? lineCommentPattern(file) : undefined;
+    const code = content.split('\n').map((line) => !isBlank(line) && !comment?.test(line));
+    return { code, parsed: true };
+}

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

@@ -10,7 +10,7 @@
  * module.
  */
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig, PatchPolicyConfig } from '../types/config.js';
+import type { FireForgeConfig, PatchLintTokenScale, PatchPolicyConfig } from '../types/config.js';
 import type { ForwardRegistrationScope } from './patch-lint-forward-registration-extended.js';
 /**
  * One patch's contribution to {@link PatchQueueContext}.
@@ -82,6 +82,8 @@ export interface PatchQueueContext {
      * `patchLint.forwardRegistration`. Absent = `support-files` only.
      */
     forwardRegistration?: ForwardRegistrationScope;
+    /** `patchLint.tokenScales`, for the scales' `minFiles` floors. */
+    tokenScales?: PatchLintTokenScale[];
 }
 /**
  * Builds a {@link PatchQueueContext} by reading every .patch file in the