@hominis/fireforge 0.49.1 → 0.50.0

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

@@ -8,6 +8,7 @@ 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 } 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';
@@ -273,10 +274,8 @@ async function computeExportPlanUnderLock(input) {
         supersededDetails,
         supersededPatches,
         manifestBefore: manifestBefore ?? null,
-        manifestAfter: {
-            version: 1,
-            patches: afterPatches,
-        },
+        // A patch landing on a retired order fills that slot.
+        manifestAfter: manifestWithRetiredSlots(manifestBefore, afterPatches),
     };
 }
 /**

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

@@ -0,0 +1,37 @@
+/**
+ * Explains an implicit-`any` checkJs finding that comes from a URL import
+ * the per-patch program cannot resolve.
+ *
+ * The program only holds patch-owned files (and, for a test, its own
+ * directory's head.js), so a `resource:///` or `chrome://` import of a
+ * module another patch creates 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,61 @@
+// 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 only holds patch-owned files (and, for a test, its own
+ * directory's head.js), so a `resource:///` or `chrome://` import of a
+ * module another patch creates 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 — ` +
+        'the module is created by another patch outside this program, a later one or one this ' +
+        'test does not share a directory with — 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.js

@@ -31,6 +31,7 @@ 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 { 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 +294,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 +337,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, [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()], 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 +351,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 +383,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);

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.js

@@ -20,7 +20,7 @@ import { collectNewFileCreatorsByPath } from './patch-lint-creators.js';
 import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-diff.js';
 import { lintPatchQueueForwardRegistrations } from './patch-lint-forward-registration.js';
 import { lintPatchQueueModuleRegistrations } from './patch-lint-module-registration.js';
-import { describeRegistrationFailure, findStagedRegistrationFailure, isLaterOwner, quoteRegistrationLine, } from './patch-lint-staged-registration.js';
+import { describeRegistrationFailure, findStagedRegistrationFailure, isLaterOwner, quoteRegistrationLine, STAGED_DEPENDENCY_REASON_PLACEHOLDER, stagedDependencyUnusedFingerprint, } from './patch-lint-staged-registration.js';
 import { loadPatchesManifest } from './patch-manifest-io.js';
 import { categoryRangeForOrder, categoryRangeLabel } from './patch-policy.js';
 import { extractNewFileContentsFromDiff } from './patch-transform.js';
@@ -493,13 +493,21 @@ export function lintPatchQueueForwardImports(ctx) {
         const stagedCommands = laterOwners
             .map((o) => `fireforge patch staged-dependency ${entry.filename} --add ` +
             `--file ${sitePath} --specifier "${specifier}" ` +
-            `--creates ${o.fullPath} --owner ${o.filename}`)
+            `--creates ${o.fullPath} --owner ${o.filename} ${STAGED_DEPENDENCY_REASON_PLACEHOLDER}`)
             .join('; ');
         issues.push({
             file: sitePath,
             check: 'forward-import',
             patches: [entry.filename],
             fingerprint: `forward-import|${sitePath}|${cleaned}|${fingerprintOwners}`,
+            stagedDeclarations: laterOwners.map((o) => ({
+                patch: entry.filename,
+                kind: 'import',
+                file: sitePath,
+                specifier,
+                creates: o.fullPath,
+                owner: o.filename,
+            })),
             message: `${sitePath} in ${entry.filename} imports "${specifier}", ` +
                 `but the matching new file is created by a later patch: ${ownersSummary}. ` +
                 'Reorder the patches so the dependency is created first, move the import ' +
@@ -518,7 +526,7 @@ export function lintPatchQueueForwardImports(ctx) {
                 file: dependency.file,
                 check: 'staged-dependency-unused',
                 patches: [entry.filename],
-                fingerprint: `staged-dependency-unused|${entry.filename}|${dependency.file}|${dependency.specifier}|${dependency.creates}|${dependency.owner ?? ''}`,
+                fingerprint: stagedDependencyUnusedFingerprint(entry.filename, dependency),
                 message: `${entry.filename} declares a staged forward import from ${dependency.file} ` +
                     `to "${dependency.specifier}" / ${dependency.creates}, but that exact forward dependency was not found. ` +
                     'Remove the stale declaration with "fireforge patch staged-dependency --remove" or update it to match the current queue.',
@@ -541,7 +549,7 @@ export function lintPatchQueueForwardImports(ctx) {
                 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 ?? ''}`,
+                fingerprint: stagedDependencyUnusedFingerprint(entry.filename, registration),
                 message: `${entry.filename} declares a staged registration in ${registration.file} ` +
                     `("${registration.line}") for ${registration.creates}, but ${describeRegistrationFailure(failure)} ` +
                     'Remove the stale declaration with: ' +

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

@@ -1,6 +1,6 @@
 /**
- * CSS patch-lint rules: introduced raw color values and non-tokenized
- * custom-property references.
+ * CSS patch-lint rules: introduced raw color values, non-tokenized
+ * custom-property references, and (opt-in) token scales over created CSS.
  *
  * Split out of `patch-lint.ts` so each rule family stays within the
  * per-file line budget. `patch-lint.ts` re-exports `lintPatchedCss` so
@@ -8,6 +8,12 @@
  */
 import type { PatchLintIssue } from '../types/commands/index.js';
 import type { FireForgeConfig } from '../types/config.js';
+/**
+ * Masks CSS block comments with spaces, preserving newlines so line
+ * numbers stay stable. An unclosed trailing `/*` is masked to EOF,
+ * matching how a CSS parser treats it.
+ */
+export declare function maskCssComments(source: string): string;
 /**
  * Lints patched CSS files for introduced raw color values and non-tokenized
  * custom properties.

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * CSS patch-lint rules: introduced raw color values and non-tokenized
- * custom-property references.
+ * CSS patch-lint rules: introduced raw color values, non-tokenized
+ * custom-property references, and (opt-in) token scales over created CSS.
  *
  * Split out of `patch-lint.ts` so each rule family stays within the
  * per-file line budget. `patch-lint.ts` re-exports `lintPatchedCss` so
@@ -13,7 +13,8 @@ import { pathExists, readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { hasRawCssColors } from '../utils/regex.js';
 import { loadFurnaceConfig } from './furnace-config.js';
-import { extractAddedLineNumbersPerFile, extractAddedLinesPerFile } from './patch-lint-diff.js';
+import { detectNewFilesInDiff, extractAddedLineNumbersPerFile, extractAddedLinesPerFile, } from './patch-lint-diff.js';
+import { lintTokenScales } from './patch-lint-token-scale.js';
 /**
  * Loads the furnace token-prefix lint inputs gracefully. Returns
  * undefined (skipping the token-prefix check) when furnace.json cannot
@@ -41,7 +42,7 @@ async function loadCssTokenContext(repoDir) {
  * numbers stay stable. An unclosed trailing `/*` is masked to EOF,
  * matching how a CSS parser treats it.
  */
-function maskCssComments(source) {
+export function maskCssComments(source) {
     const masked = source.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, ' '));
     const openerIndex = masked.indexOf('/*');
     if (openerIndex === -1)
@@ -197,6 +198,9 @@ export async function lintPatchedCss(repoDir, affectedFiles, diffContent, config
     const addedLineNumbersByFile = diffContent
         ? extractAddedLineNumbersPerFile(diffContent)
         : undefined;
+    // `patchLint.tokenScales` governs only CSS the patch creates.
+    const tokenScales = config?.patchLint?.tokenScales ?? [];
+    const createdFiles = diffContent && tokenScales.length > 0 ? detectNewFilesInDiff(diffContent) : new Set();
     for (const file of cssFiles) {
         const filePath = join(repoDir, file);
         if (!(await pathExists(filePath)))
@@ -213,6 +217,8 @@ export async function lintPatchedCss(repoDir, affectedFiles, diffContent, config
             issues,
         });
         checkTokenPrefixViolations(file, cssContent, addedLinesByFile, tokenContext, issues);
+        if (createdFiles.has(file))
+            issues.push(...lintTokenScales(file, rawCss, tokenScales));
     }
     return issues;
 }

package/dist/src/core/patch-lint-file-size.d.ts

@@ -13,7 +13,9 @@
  * lines failed a gate with a message calling 750 soft. The message below
  * says what the band is (a warning) and what a zero-warning gate does with
  * it, and the thresholds are now tunable, so a project whose file-size
- * policy differs has a dial instead of an argument.
+ * policy differs has a dial instead of an argument. The notice band is the
+ * design target: advisory, and its message says so rather than borrowing
+ * the warning band's gate sentence.
  */
 import type { PatchLintFileSizeThresholds } from '../types/config.js';
 /** A fully resolved threshold triple. */
@@ -38,14 +40,19 @@ export declare function resolveFileSizeThresholds(overrides: PatchLintFileSizeTh
 /**
  * Renders the `file-too-large` message for a given band.
  *
- * The `warning` and `notice` bands name the gate consequence explicitly:
- * the number is advisory to patch-lint and blocking to a `--max-warnings 0`
- * gate, and an operator deciding whether to decompose a file needs to know
- * which of those they are looking at.
+ * Each band says what it means for a gate. A notice is over the design
+ * target and advisory: it never fails `--max-warnings 0`, and saying it
+ * did once got a test suite split for nothing. A warning is what a
+ * zero-warning gate fails on, so it names that and the dial. Only the
+ * error band suggests splitting, because a test-file split pushes against
+ * one suite per subject and should not be the default advice below it.
+ * Every band names the unit, which matters once `fileSizeMetric` makes
+ * code lines a choice.
  */
 export declare function formatFileTooLargeMessage(args: {
     label: string;
     lineCount: number;
+    unit: 'lines' | 'code lines';
     thresholds: ResolvedFileSizeTier;
     band: 'notice' | 'warning' | 'error';
     verb: string;

package/dist/src/core/patch-lint-file-size.js

@@ -14,7 +14,9 @@
  * lines failed a gate with a message calling 750 soft. The message below
  * says what the band is (a warning) and what a zero-warning gate does with
  * it, and the thresholds are now tunable, so a project whose file-size
- * policy differs has a dial instead of an argument.
+ * policy differs has a dial instead of an argument. The notice band is the
+ * design target: advisory, and its message says so rather than borrowing
+ * the warning band's gate sentence.
  */
 /** Built-in defaults, per file class. */
 export const DEFAULT_FILE_SIZE_THRESHOLDS = {
@@ -36,18 +38,27 @@ export function resolveFileSizeThresholds(overrides, isTest) {
 /**
  * Renders the `file-too-large` message for a given band.
  *
- * The `warning` and `notice` bands name the gate consequence explicitly:
- * the number is advisory to patch-lint and blocking to a `--max-warnings 0`
- * gate, and an operator deciding whether to decompose a file needs to know
- * which of those they are looking at.
+ * Each band says what it means for a gate. A notice is over the design
+ * target and advisory: it never fails `--max-warnings 0`, and saying it
+ * did once got a test suite split for nothing. A warning is what a
+ * zero-warning gate fails on, so it names that and the dial. Only the
+ * error band suggests splitting, because a test-file split pushes against
+ * one suite per subject and should not be the default advice below it.
+ * Every band names the unit, which matters once `fileSizeMetric` makes
+ * code lines a choice.
  */
 export function formatFileTooLargeMessage(args) {
-    const { label, lineCount, thresholds, band, verb } = args;
+    const { label, lineCount, unit, thresholds, band, verb } = args;
+    const measured = `${label} has ${lineCount} ${unit}`;
     if (band === 'error') {
-        return `${label} has ${lineCount} lines (error threshold: ${thresholds.error}). Consider ${verb}.`;
+        return `${measured} (error threshold: ${thresholds.error}). Consider ${verb}.`;
     }
-    return (`${label} has ${lineCount} lines (warning threshold: ${thresholds.warning}, ` +
-        `error threshold: ${thresholds.error}). Consider ${verb}. ` +
-        `Reported as a ${band}, which a gate running --max-warnings 0 treats as a failure; ` +
-        `tune "patchLint.fileSizeThresholds" if these limits are wrong for this project.`);
+    const limits = `(warning threshold: ${thresholds.warning}, error threshold: ${thresholds.error})`;
+    if (band === 'notice') {
+        return (`${measured}, over the design target of ${thresholds.notice} ${limits}. ` +
+            'Advisory; does not fail --max-warnings 0.');
+    }
+    return (`${measured} ${limits}. ` +
+        'Reported as a warning, which a gate running --max-warnings 0 treats as a failure; ' +
+        'tune "patchLint.fileSizeThresholds" if these limits are wrong for this project.');
 }

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

@@ -24,6 +24,24 @@ export interface ForwardRegistration {
     /** Paste-and-run declaration that records the stage as intentional. */
     command: string;
 }
+/** True for a jar.mn, moz.build or test manifest, the carriers {@link resolveCarrierReferences} reads. */
+export declare function isRegistrationCarrier(file: string): boolean;
+/**
+ * The engine paths named by the lines of one jar.mn, moz.build or test
+ * manifest, resolved the way this rule resolves them. Exported for a caller
+ * outside the queue lint (re-export's adjacency belt asks which files a
+ * patch's added registration lines name). A `customElements.js` chrome URL
+ * resolves only through the queue's jar.mn index, so it is not covered.
+ *
+ * @param rawPath - Engine-relative path of the carrier
+ * @param content - The carrier lines to read (typically the added ones)
+ * @returns One entry per resolvable token. `exact` is set when it has no wildcard.
+ */
+export declare function resolveCarrierReferences(rawPath: string, content: string): {
+    line: string;
+    exact?: string;
+    matches: (candidate: string) => boolean;
+}[];
 /** The discharge command, in the exact shape the support-files arm prints. */
 export declare function formatRegistrationDeclaration(patch: string, file: string, line: string, creates: string, owner: string): string;
 /**

package/dist/src/core/patch-lint-forward-registration-extended.js

@@ -28,7 +28,7 @@ import { basename, dirname, posix } from 'node:path';
 import { normalizePathSlashes } from '../utils/paths.js';
 import { escapeRegex } from '../utils/regex.js';
 import { parseJarMnEntry } from './build-audit-registration.js';
-import { isLaterOwner, quoteRegistrationLine } from './patch-lint-staged-registration.js';
+import { isLaterOwner, quoteRegistrationLine, STAGED_DEPENDENCY_REASON_PLACEHOLDER, } from './patch-lint-staged-registration.js';
 const TEST_MANIFEST_BASENAMES = new Set([
     'xpcshell.toml',
     'xpcshell.ini',
@@ -153,20 +153,45 @@ function customElementsReferences(file, content, jarTargets) {
     }
     return refs;
 }
+/** True for a jar.mn, moz.build or test manifest, the carriers {@link resolveCarrierReferences} reads. */
+export function isRegistrationCarrier(file) {
+    const name = basename(normalizePathSlashes(file));
+    return name === 'jar.mn' || name === 'moz.build' || TEST_MANIFEST_BASENAMES.has(name);
+}
+function carrierReferences(file, content) {
+    const name = basename(file);
+    if (name === 'jar.mn')
+        return jarMnReferences(file, content);
+    if (name === 'moz.build')
+        return mozBuildReferences(file, content);
+    if (TEST_MANIFEST_BASENAMES.has(name))
+        return testManifestReferences(file, content);
+    return [];
+}
+/**
+ * The engine paths named by the lines of one jar.mn, moz.build or test
+ * manifest, resolved the way this rule resolves them. Exported for a caller
+ * outside the queue lint (re-export's adjacency belt asks which files a
+ * patch's added registration lines name). A `customElements.js` chrome URL
+ * resolves only through the queue's jar.mn index, so it is not covered.
+ *
+ * @param rawPath - Engine-relative path of the carrier
+ * @param content - The carrier lines to read (typically the added ones)
+ * @returns One entry per resolvable token. `exact` is set when it has no wildcard.
+ */
+export function resolveCarrierReferences(rawPath, content) {
+    return carrierReferences(normalizePathSlashes(rawPath), content);
+}
 function referencesFor(entry, jarTargets) {
     const refs = [];
     for (const [rawPath, content] of [...entry.newFiles, ...entry.modifiedFileAdditions]) {
         const file = normalizePathSlashes(rawPath);
-        const name = basename(file);
-        if (name === 'jar.mn')
-            refs.push(...jarMnReferences(file, content));
-        else if (name === 'moz.build')
-            refs.push(...mozBuildReferences(file, content));
-        else if (TEST_MANIFEST_BASENAMES.has(name))
-            refs.push(...testManifestReferences(file, content));
-        else if (name === 'customElements.js') {
+        if (basename(file) === 'customElements.js') {
             refs.push(...customElementsReferences(file, content, jarTargets));
         }
+        else {
+            refs.push(...carrierReferences(file, content));
+        }
     }
     return refs;
 }
@@ -178,7 +203,7 @@ function isDeclared(entry, file, created) {
 export function formatRegistrationDeclaration(patch, file, line, creates, owner) {
     return (`fireforge patch staged-dependency ${patch} --add --kind registration ` +
         `--file ${file} --line "${quoteRegistrationLine(line)}" ` +
-        `--creates ${creates} --owner ${owner}`);
+        `--creates ${creates} --owner ${owner} ${STAGED_DEPENDENCY_REASON_PLACEHOLDER}`);
 }
 /**
  * Finds every undeclared forward registration in the extended carriers: