@hominis/fireforge 0.44.4 → 0.46.0

package/dist/src/core/patch-lint-unmanaged-companion.js

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Recognizes the one shape where the undefined-identifier hint sends the
+ * operator at the wrong remedy — and where taking that remedy would MASK a
+ * real bug.
+ *
+ * The shape: helpers are hoisted out of duplicated test files into a new
+ * `head_settings.js` that a managed `head.js` pulls in with
+ * `loadSubScript`. Until that companion is exported it belongs to no patch,
+ * so the per-patch checkJs program — which only ever loads patch-owned
+ * roots — cannot see any of its declarations. Every use of every hoisted
+ * helper is then reported as `Cannot find name`, and the generic hint
+ * offers three remedies of which the shim is the easiest: adding the
+ * globals to `extraShim` makes all of the warnings disappear AND makes a
+ * genuinely missing helper undetectable forever after.
+ *
+ * The warnings themselves are correct — the per-patch program's honest view
+ * of a file that is in no patch. Only the advice is wrong. FireForge
+ * already knows ownership, so when every undefined name in a file is
+ * declared at the top level of an UNMANAGED file that a managed head loads,
+ * it can name that file and the adoption command instead.
+ *
+ * Detection is deliberately conservative on both halves: a companion must
+ * be reachable from an actual `loadSubScript` call, and EVERY undefined
+ * name must resolve inside it. One unresolved name means the file may
+ * genuinely be missing a helper, and the generic hint stays.
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { UNDEFINED_IDENTIFIER_HINT } from './typecheck-shim.js';
+/**
+ * String literals passed anywhere inside a `loadSubScript(...)` call.
+ *
+ * The mochitest idiom is
+ * `Services.scriptloader.loadSubScript(getRootDirectory(gTestPath) + "head_settings.js", this)`,
+ * so the useful signal is the `.js` literal inside the call, not a
+ * resolvable URL — the path half is computed at runtime.
+ */
+export function findLoadSubScriptTargets(source) {
+    const targets = [];
+    // Scanned to the statement terminator rather than to a closing paren:
+    // the idiomatic argument is itself a call (`getRootDirectory(gTestPath) +
+    // "head_settings.js"`), so a non-greedy `\)` stops on the INNER paren and
+    // never reaches the literal.
+    for (const call of source.matchAll(/loadSubScript\s*\(/g)) {
+        const from = call.index + call[0].length;
+        const semicolon = source.indexOf(';', from);
+        const to = semicolon === -1 ? from + CALL_SCAN_LIMIT : Math.min(semicolon, from + CALL_SCAN_LIMIT);
+        for (const literal of source.slice(from, to).matchAll(/["'`]([^"'`]*\.js)["'`]/g)) {
+            const value = literal[1];
+            if (value !== undefined && value.length > 0)
+                targets.push(value);
+        }
+    }
+    return targets;
+}
+/** How far past a `loadSubScript(` the argument scan looks. */
+const CALL_SCAN_LIMIT = 400;
+/**
+ * Top-level declaration names in a script-scope file.
+ *
+ * Regex rather than a TS program on purpose: this runs only to decide the
+ * WORDING of a hint, the file is by definition outside every program the
+ * pass built, and a missed declaration degrades to the generic hint rather
+ * than to a wrong answer. Matching is anchored at column zero so a nested
+ * declaration inside a function body is not mistaken for a global.
+ */
+export function collectTopLevelDeclarations(source) {
+    const names = new Set();
+    const patterns = [
+        /^(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/gm,
+        /^(?:const|let|var)\s+([A-Za-z_$][\w$]*)/gm,
+        /^class\s+([A-Za-z_$][\w$]*)/gm,
+    ];
+    for (const pattern of patterns) {
+        for (const match of source.matchAll(pattern)) {
+            const name = match[1];
+            if (name !== undefined)
+                names.add(name);
+        }
+    }
+    return names;
+}
+/**
+ * Extracts the identifier from a `Cannot find name 'X'` diagnostic message,
+ * or undefined when the message is not one.
+ */
+function extractUndefinedIdentifier(message) {
+    const match = /Cannot find name '([^']+)'/.exec(message);
+    return match?.[1];
+}
+/**
+ * Resolves the unmanaged companions reachable from a set of managed head
+ * files, given a reader for repo-relative file content.
+ *
+ * A candidate qualifies only when it is NOT in `ownedFiles` and its content
+ * can be read — an unreadable or absent target is simply not a companion,
+ * and the generic hint applies.
+ *
+ * @param heads - Repo-relative managed head files, with their sources
+ * @param ownedFiles - Every patch-owned repo-relative path
+ * @param readFile - Reads a repo-relative file, or returns undefined
+ */
+export async function resolveUnmanagedCompanions(heads, ownedFiles, readFile) {
+    const companions = [];
+    const seen = new Set();
+    for (const head of heads) {
+        const dir = head.file.slice(0, head.file.lastIndexOf('/') + 1);
+        for (const target of findLoadSubScriptTargets(head.source)) {
+            // Only same-directory targets: the runtime path is computed from the
+            // test's own directory, and a bare basename is what that idiom yields.
+            const candidate = `${dir}${target.slice(target.lastIndexOf('/') + 1)}`;
+            if (candidate === head.file || ownedFiles.has(candidate) || seen.has(candidate))
+                continue;
+            seen.add(candidate);
+            const source = await readFile(candidate);
+            if (source === undefined)
+                continue;
+            companions.push({
+                file: candidate,
+                loadedBy: head.file,
+                declarations: collectTopLevelDeclarations(source),
+            });
+        }
+    }
+    return companions;
+}
+/**
+ * The replacement hint, when every undefined name resolves in one
+ * unmanaged companion.
+ *
+ * States the ownership fact first (that is the diagnosis), then the
+ * adoption command, and explicitly rules the shim OUT — the shim is what an
+ * operator reaches for by default here, and it is the one remedy that
+ * permanently hides a genuinely missing helper.
+ */
+export function formatUnmanagedCompanionHint(companion) {
+    return (`(undefined identifier — every one of them is declared in ${companion.file}, which ` +
+        `${companion.loadedBy} loads via loadSubScript but which NO patch owns yet, so the ` +
+        `per-patch program cannot see it. Adopt it with ` +
+        `"fireforge re-export <patch> --scan --scan-file ${companion.file}". Do NOT add these ` +
+        `globals to the extra shim: that silences these warnings and every future genuinely ` +
+        `missing helper with them.)`);
+}
+/**
+ * Picks the companion that explains EVERY undefined identifier in
+ * `messages`, or undefined when none does.
+ *
+ * @param messages - Diagnostic messages reported for one file
+ * @param companions - Candidates from {@link resolveUnmanagedCompanions}
+ */
+export function explainUndefinedIdentifiers(messages, companions) {
+    const names = messages
+        .map((message) => extractUndefinedIdentifier(message))
+        .filter((name) => name !== undefined);
+    if (names.length === 0)
+        return undefined;
+    // Only the undefined-identifier diagnostics are explained here; a file
+    // carrying OTHER type errors still gets those reported untouched.
+    return companions.find((companion) => names.every((name) => companion.declarations.has(name)));
+}
+/**
+ * Reads the head files in the owned test set and resolves the UNMANAGED
+ * companions they pull in with `loadSubScript`. Hoisting shared helpers
+ * into such a companion leaves it unowned until export, and every use of
+ * every helper then reports `Cannot find name` from an honest per-patch
+ * program — see `patch-lint-unmanaged-companion.ts` for why the generic
+ * hint is actively harmful there.
+ *
+ * Best-effort: an unreadable head simply contributes no companions.
+ */
+export async function collectUnmanagedCompanions(repoDir, files, ownedFiles) {
+    const heads = [];
+    for (const file of files) {
+        const base = file.split('/').pop() ?? '';
+        if (!/^head(?:_.*)?\.js$/.test(base))
+            continue;
+        try {
+            heads.push({ file, source: await readFile(join(repoDir, file), 'utf8') });
+        }
+        catch {
+            continue;
+        }
+    }
+    if (heads.length === 0)
+        return [];
+    return resolveUnmanagedCompanions(heads, ownedFiles, async (rel) => {
+        try {
+            return await readFile(join(repoDir, rel), 'utf8');
+        }
+        catch {
+            return undefined;
+        }
+    });
+}
+/**
+ * Swaps the generic undefined-identifier hint for the ownership hint when
+ * one unmanaged companion explains EVERY undefined name in the file. Any
+ * other issue in the list is returned untouched.
+ */
+export function retargetUnmanagedCompanionHints(issues, companions) {
+    if (companions.length === 0)
+        return [...issues];
+    const undefinedIssues = issues.filter((issue) => issue.message.includes(UNDEFINED_IDENTIFIER_HINT));
+    if (undefinedIssues.length === 0)
+        return [...issues];
+    const companion = explainUndefinedIdentifiers(undefinedIssues.map((issue) => issue.message), companions);
+    if (!companion)
+        return [...issues];
+    const hint = formatUnmanagedCompanionHint(companion);
+    return issues.map((issue) => issue.message.includes(UNDEFINED_IDENTIFIER_HINT)
+        ? { ...issue, message: issue.message.replace(UNDEFINED_IDENTIFIER_HINT, hint) }
+        : issue);
+}

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

@@ -2,7 +2,8 @@ import type { PatchLintIssue } from '../types/commands/index.js';
 import type { FireForgeConfig, ProjectLicense } from '../types/config.js';
 import { type CommentStyle } from './license-headers.js';
 import { lintPatchedCss } from './patch-lint-css.js';
-export * from './patch-lint-reexports.js';
+export * from './patch-lint-cross.js';
+export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
 export { lintPatchedCss };
 /**
  * Canonical `[check] file: message` rendering of a patch-lint issue — the
@@ -132,6 +133,17 @@ export type PatchSizeTierDecision = {
  * defensive-for-tests choice.
  */
 export declare function resolvePatchSizeTier(filesAffected: ReadonlyArray<string>, patchTier?: 'branding'): PatchSizeTierDecision;
+/** Line and file-count thresholds governing one patch-size tier. */
+export interface PatchSizeThresholds {
+    /** Added-line counts at which notice/warning/error issues fire. */
+    lines: {
+        notice: number;
+        warning: number;
+        error: number;
+    };
+    /** Maximum number of files a patch may touch before an issue fires. */
+    maxFiles: number;
+}
 /**
  * Read-only view of the size thresholds a tier enforces.
  * Public-API companion to {@link resolvePatchSizeTier} /
@@ -139,14 +151,7 @@ export declare function resolvePatchSizeTier(filesAffected: ReadonlyArray<string
  * checks against the SAME numbers `large-patch-lines` /
  * `large-patch-files` fire on instead of mirroring them.
  */
-export declare function getPatchSizeThresholds(tier: 'general' | 'test' | 'branding'): {
-    lines: {
-        notice: number;
-        warning: number;
-        error: number;
-    };
-    maxFiles: number;
-};
+export declare function getPatchSizeThresholds(tier: 'general' | 'test' | 'branding'): PatchSizeThresholds;
 /**
  * Checks patch size and emits advisory warnings.
  *

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

@@ -8,11 +8,13 @@ import { lintChromeScriptJsDocForFile } from './patch-lint-chrome-jsdoc.js';
 import { lintPatchedCss } from './patch-lint-css.js';
 import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-diff.js';
 import { AGGREGATE_PATCH_FILE } from './patch-lint-diff-tag.js';
+import { formatFileTooLargeMessage, resolveFileSizeThresholds } from './patch-lint-file-size.js';
 import { hasRelativeImport } from './patch-lint-imports.js';
 import { validateExportJsDoc } from './patch-lint-jsdoc.js';
 import { lintMozBuildSortedLists } from './patch-lint-mozbuild.js';
 import { lintObserverTopics } from './patch-lint-observer.js';
 import { resolvePatchOwnedChromeScripts, resolvePatchOwnedSysMjs, resolvePatchOwnedTestScripts, } from './patch-lint-ownership.js';
+import { invokePatchLintPrettier } from './patch-lint-prettier.js';
 // ---------------------------------------------------------------------------
 // Cross-patch lint re-exports
 // ---------------------------------------------------------------------------
@@ -20,9 +22,10 @@ import { resolvePatchOwnedChromeScripts, resolvePatchOwnedSysMjs, resolvePatchOw
 // The cross-patch lint infrastructure (queue context builder,
 // duplicate-creation and forward-import rules, ignore marker) lives in
 // `patch-lint-cross.ts` so the per-patch and cross-patch rule bodies each
-// stay within the per-file line budget. The public surface is re-exported
-// from `patch-lint-reexports.ts` so callers keep importing from one module.
-export * from './patch-lint-reexports.js';
+// stay within the per-file line budget. Its surface is re-exported here so
+// callers keep importing from one module.
+export * from './patch-lint-cross.js';
+export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
 // The CSS rule bodies live in `patch-lint-css.ts` (same per-file-budget
 // split as the other rule families); re-export the imported binding so
 // callers and tests keep importing `lintPatchedCss` from this module.
@@ -31,10 +34,6 @@ export { lintPatchedCss };
 // Helpers
 // ---------------------------------------------------------------------------
 const JS_EXTENSIONS = ['.js', '.mjs', '.jsm'];
-const FILE_SIZE_THRESHOLDS = {
-    general: { notice: 500, warning: 750, error: 900 },
-    test: { notice: 1200, warning: 1400, error: 1600 },
-};
 /**
  * Counts the lines of `content` the way `wc -l` reports them: a trailing
  * newline terminates the last line rather than starting an empty extra one.
@@ -407,31 +406,22 @@ export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config, pa
         if (isNew) {
             const lineCount = countContentLines(content);
             const isTest = isTestFile(file);
-            const thresholds = isTest ? FILE_SIZE_THRESHOLDS.test : FILE_SIZE_THRESHOLDS.general;
+            const thresholds = resolveFileSizeThresholds(config.patchLint?.fileSizeThresholds, isTest);
             const label = isTest ? 'Test file' : 'New file';
             const verb = isTest ? 'splitting' : 'decomposing';
-            if (lineCount > thresholds.error) {
-                issues.push({
-                    file,
-                    check: 'file-too-large',
-                    message: `${label} has ${lineCount} lines (hard limit: ${thresholds.error}). Consider ${verb}.`,
-                    severity: 'error',
-                });
-            }
-            else if (lineCount > thresholds.warning) {
+            const band = lineCount > thresholds.error
+                ? 'error'
+                : lineCount > thresholds.warning
+                    ? 'warning'
+                    : lineCount > thresholds.notice
+                        ? 'notice'
+                        : undefined;
+            if (band !== undefined) {
                 issues.push({
                     file,
                     check: 'file-too-large',
-                    message: `${label} has ${lineCount} lines (soft limit: ${thresholds.warning}, hard limit: ${thresholds.error}). Consider ${verb}.`,
-                    severity: 'warning',
-                });
-            }
-            else if (lineCount > thresholds.notice) {
-                issues.push({
-                    file,
-                    check: 'file-too-large',
-                    message: `${label} has ${lineCount} lines (soft limit: ${thresholds.warning}, hard limit: ${thresholds.error}). Consider ${verb}.`,
-                    severity: 'notice',
+                    message: formatFileTooLargeMessage({ label, lineCount, thresholds, band, verb }),
+                    severity: band,
                 });
             }
         }
@@ -715,6 +705,16 @@ export async function lintExportedPatch(repoDir, affectedFiles, diffContent, con
             }
         }
     }
+    // Prettier over patch-owned .sys.mjs. Deliberately NOT part of the
+    // precomputedCheckJs short-circuit: it is a separate tool with its own
+    // gate, and a queue-wide program has no equivalent to share. Scoped to
+    // the files THIS patch owns, run from engine/ so the engine's own config
+    // and ignore file decide (see `patch-lint-prettier.ts`).
+    const prettierGate = config.patchLint?.prettier ?? 'off';
+    if (prettierGate !== 'off' && patchOwnedFiles.size > 0) {
+        const scoped = [...patchOwnedFiles].filter((file) => !options?.checkJsReportScope || options.checkJsReportScope.has(file));
+        issues.push(...(await invokePatchLintPrettier(repoDir, dirname(repoDir), scoped.sort(), prettierGate)));
+    }
     // Filter out ignored checks last so every rule still runs (keeps the
     // implementation uniform) but suppressed rules do not surface. We do not
     // reclassify severities — an ignored error simply drops, mirroring how

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

@@ -16,12 +16,12 @@ const PATCH_DIRECTORY_LOCK = '.fireforge-patches.lock';
  * session lock's progress line so operators read one shape for both locks.
  */
 function formatWaitProgressLine(waitedMs, timeoutMs, holder) {
-    const progress = `${String(Math.round(waitedMs / 1000))}s of up to ${String(Math.round(timeoutMs / 1000))}s`;
+    const progress = `${Math.round(waitedMs / 1000)}s of up to ${Math.round(timeoutMs / 1000)}s`;
     if (holder === undefined) {
         return `Waiting for the FireForge patch directory lock — ${progress}.`;
     }
     const details = holder.metadata.length > 0 ? ` (${holder.metadata.join(', ')})` : '';
-    return `Waiting for the FireForge patch directory lock held by PID ${String(holder.pid)}${details} — ${progress}.`;
+    return `Waiting for the FireForge patch directory lock held by PID ${holder.pid}${details} — ${progress}.`;
 }
 /**
  * Asserts that this process is inside {@link withPatchDirectoryLock} for the
@@ -47,7 +47,7 @@ export async function assertPatchDirectoryLockHeld(patchesDir, context) {
     const status = await readLockStatus(join(patchesDir, PATCH_DIRECTORY_LOCK));
     assert(status.held, () => `patch directory lock is held before ${context}`);
     assert(status.holder === undefined || status.holder.pid === process.pid, () => `patch directory lock is owned by this process before ${context} ` +
-        `(held by PID ${String(status.holder?.pid)}, we are ${String(process.pid)})`);
+        `(held by PID ${status.holder?.pid}, we are ${process.pid})`);
 }
 /**
  * Runs a patch directory mutation while holding an exclusive filesystem lock.

package/dist/src/core/patch-manifest-io.js

@@ -98,17 +98,18 @@ export async function mutatePatchRowsInManifest(patchesDir, filenames, mutator)
     if (!(await pathExistsStrict(manifestPath)))
         return null;
     const rawManifest = await readJson(manifestPath);
+    // `validatePatchesManifest` has already rejected a manifest that is not an
+    // object with an array of object rows (it throws the corruption error the
+    // caller expects), so the shape re-checks below are FireForge's own
+    // invariants, not input validation: failing them means the validator and
+    // this walker disagree about the manifest schema, which is a bug here.
     const beforeManifest = validatePatchesManifest(rawManifest);
-    if (!isObject(rawManifest) || !isArray(rawManifest['patches'])) {
-        throw new Error('patches.json must be a JSON object with a patches array');
-    }
+    assert(isObject(rawManifest) && isArray(rawManifest['patches']), 'validated patches.json is a JSON object with a patches array');
     const filenameSet = new Set(filenames);
     if (filenameSet.size === 0)
         return [];
-    const rawPatches = rawManifest['patches'].map((entry) => {
-        if (!isObject(entry)) {
-            throw new Error('patches.json patches entries must be objects');
-        }
+    const rawPatches = rawManifest['patches'].map((entry, index) => {
+        assert(isObject(entry), () => `validated patches.json row ${index} is an object`);
         return { ...entry };
     });
     const changedIndexes = [];

package/dist/src/core/patch-parse.d.ts

@@ -1,14 +1,25 @@
 /**
- * Pure parsing functions for extracting information from patch files. All
- * functions are synchronous and operate on string content.
+ * Renders a patch order as the zero-padded prefix used in filenames and in
+ * every message that names an order.
  *
- * This module is the ONE unified-diff walker in the codebase. Hand-rolled
- * `diff --git` walkers diverge in ways that matter: CRLF handling (a
- * CRLF-saved patch file silently fails target-file matching and
- * `\ No newline` detection on Windows), quoted-path support, and greedy path
- * captures that mis-split any path containing ` b/`. New diff-shaped parsing
- * must build on {@link parseDiffSections} rather than re-walking lines.
+ * Eleven call sites across `patch-policy`, `patch-export`, `export-flow`,
+ * `export-placement-policy` and `patch move-files` spelled this as
+ * `String(order).padStart(3, '0')`, so the padding width lived in eleven
+ * places while the filenames it has to agree with are produced in one.
+ * @param order - Numeric patch order.
+ * @param width - Prefix width; defaults to the on-disk convention.
+ * @returns The zero-padded order, e.g. `007`.
  */
+export declare function formatPatchOrder(order: number, width?: number): string;
+/**
+ * Renders an inclusive order range the way `patchPolicy` diagnostics name it.
+ * @param range - Inclusive `from`/`to` order bounds.
+ * @returns The range label, e.g. `100-199`.
+ */
+export declare function formatOrderRange(range: {
+    from: number;
+    to: number;
+}): string;
 /**
  * Extracts the order number from a patch filename.
  * Expects format like "001-description.patch"

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

@@ -11,6 +11,31 @@ import { assert } from '../utils/assert.js';
  * captures that mis-split any path containing ` b/`. New diff-shaped parsing
  * must build on {@link parseDiffSections} rather than re-walking lines.
  */
+/** Width of the zero-padded numeric prefix on a patch filename ("001-…"). */
+const PATCH_ORDER_WIDTH = 3;
+/**
+ * Renders a patch order as the zero-padded prefix used in filenames and in
+ * every message that names an order.
+ *
+ * Eleven call sites across `patch-policy`, `patch-export`, `export-flow`,
+ * `export-placement-policy` and `patch move-files` spelled this as
+ * `String(order).padStart(3, '0')`, so the padding width lived in eleven
+ * places while the filenames it has to agree with are produced in one.
+ * @param order - Numeric patch order.
+ * @param width - Prefix width; defaults to the on-disk convention.
+ * @returns The zero-padded order, e.g. `007`.
+ */
+export function formatPatchOrder(order, width = PATCH_ORDER_WIDTH) {
+    return String(order).padStart(width, '0');
+}
+/**
+ * Renders an inclusive order range the way `patchPolicy` diagnostics name it.
+ * @param range - Inclusive `from`/`to` order bounds.
+ * @returns The range label, e.g. `100-199`.
+ */
+export function formatOrderRange(range) {
+    return `${formatPatchOrder(range.from)}-${formatPatchOrder(range.to)}`;
+}
 /**
  * Extracts the order number from a patch filename.
  * Expects format like "001-description.patch"

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

@@ -11,6 +11,7 @@ import { InvalidArgumentError } from '../errors/base.js';
 import { warn } from '../utils/logger.js';
 import { PATCH_CATEGORIES } from '../utils/validation.js';
 import { rewriteStagedDependencyOwners } from './patch-manifest-io.js';
+import { formatOrderRange, formatPatchOrder } from './patch-parse.js';
 /** Default patch filename contract used when a policy omits `filenamePattern`. */
 const DEFAULT_PATCH_POLICY_FILENAME_PATTERN = '^(?<order>\\d{3})-(?<category>[a-z][a-z0-9-]*)-(?<slug>[a-z0-9-]+)\\.patch$';
 function policy(config) {
@@ -19,13 +20,6 @@ function policy(config) {
 function mutationMode(config) {
     return policy(config)?.mutationMode ?? 'error';
 }
-function issueSeverity(config) {
-    return mutationMode(config) === 'warn' ? 'warning' : 'error';
-}
-/** Returns true when the loaded config includes an opt-in patch policy. */
-function hasPatchPolicy(config) {
-    return policy(config) !== undefined;
-}
 /** Returns valid categories for prompts and CLI validation under the config. */
 export function getPatchPolicyCategories(config) {
     const cfg = policy(config);
@@ -42,9 +36,6 @@ export function isCategoryAllowedByConfig(config, category) {
         return PATCH_CATEGORIES.includes(category);
     return cfg.ranges.some((range) => range.category === category);
 }
-function rangeLabel(range) {
-    return `${String(range.from).padStart(3, '0')}-${String(range.to).padStart(3, '0')}`;
-}
 /**
  * Human-readable label for a category's configured ranges, e.g. `300-399`.
  * Exported for the forward-import hint, which must render the
@@ -54,7 +45,7 @@ export function categoryRangeLabel(ranges, category) {
     const matches = ranges.filter((range) => range.category === category);
     if (matches.length === 0)
         return '(no configured range)';
-    return matches.map(rangeLabel).join(', ');
+    return matches.map(formatOrderRange).join(', ');
 }
 function reservedRangeForOrder(cfg, order) {
     return cfg.reservedRanges?.find((range) => order >= range.from && order <= range.to) ?? null;
@@ -73,9 +64,6 @@ export function categoryRangeForOrder(cfg, category, order) {
 function anyRangeForOrder(cfg, order) {
     return cfg.ranges.find((range) => order >= range.from && order <= range.to) ?? null;
 }
-function compileFilenamePattern(cfg) {
-    return new RegExp(cfg.filenamePattern ?? DEFAULT_PATCH_POLICY_FILENAME_PATTERN);
-}
 function parseFilenameWithPolicy(cfg, patch, severity) {
     if (cfg.filenamePattern === undefined) {
         const defaultMatch = /^(?<order>\d{3})-(?<rest>[a-z0-9-]+)\.patch$/.exec(patch.filename);
@@ -117,7 +105,7 @@ function parseFilenameWithPolicy(cfg, patch, severity) {
         }
         return { order: Number.parseInt(orderRaw, 10), category };
     }
-    const pattern = compileFilenamePattern(cfg);
+    const pattern = new RegExp(cfg.filenamePattern ?? DEFAULT_PATCH_POLICY_FILENAME_PATTERN);
     const match = pattern.exec(patch.filename);
     if (!match) {
         return [
@@ -188,7 +176,7 @@ function evaluatePatchMetadata(cfg, patch, severity) {
                 code: 'reserved-range',
                 filename: patch.filename,
                 severity,
-                message: `${patch.filename} is in reserved range ${rangeLabel(reserved)}. ` +
+                message: `${patch.filename} is in reserved range ${formatOrderRange(reserved)}. ` +
                     'Reserved ranges require an exact patchPolicy.reservedRanges[].allowed filename exception.',
             });
             return issues;
@@ -198,7 +186,7 @@ function evaluatePatchMetadata(cfg, patch, severity) {
                 code: 'reserved-documentation',
                 filename: patch.filename,
                 severity,
-                message: `${patch.filename} is allowlisted for reserved range ${rangeLabel(reserved)}, ` +
+                message: `${patch.filename} is allowlisted for reserved range ${formatOrderRange(reserved)}, ` +
                     'but the allowlist entry must include either "adr" or "documentation".',
             });
         }
@@ -210,7 +198,7 @@ function evaluatePatchMetadata(cfg, patch, severity) {
                     code: 'reserved-files',
                     filename: patch.filename,
                     severity,
-                    message: `${patch.filename} is allowlisted for reserved range ${rangeLabel(reserved)}, ` +
+                    message: `${patch.filename} is allowlisted for reserved range ${formatOrderRange(reserved)}, ` +
                         `but touches file(s) outside its reserved allowlist: ${extraFiles.join(', ')}.`,
                 });
             }
@@ -222,8 +210,8 @@ function evaluatePatchMetadata(cfg, patch, severity) {
         const owner = anyRangeForOrder(cfg, patch.order);
         const expected = categoryRangeLabel(cfg.ranges, patch.category);
         const actual = owner !== null
-            ? `${String(patch.order).padStart(3, '0')} is configured for ${owner.category} (${rangeLabel(owner)})`
-            : `${String(patch.order).padStart(3, '0')} is outside all configured ranges`;
+            ? `${formatPatchOrder(patch.order)} is configured for ${owner.category} (${formatOrderRange(owner)})`
+            : `${formatPatchOrder(patch.order)} is outside all configured ranges`;
         issues.push({
             code: 'category-range',
             filename: patch.filename,
@@ -262,10 +250,10 @@ function evaluateGaps(cfg, patches, severity) {
         if (missing.length > 0) {
             issues.push({
                 code: 'numeric-gap',
-                filename: `${range.category}:${rangeLabel(range)}`,
+                filename: `${range.category}:${formatOrderRange(range)}`,
                 severity,
-                message: `${range.category} range ${rangeLabel(range)} has numeric gap(s): ` +
-                    missing.map((order) => String(order).padStart(3, '0')).join(', ') +
+                message: `${range.category} range ${formatOrderRange(range)} has numeric gap(s): ` +
+                    missing.map((order) => formatPatchOrder(order)).join(', ') +
                     '. patchPolicy.allowGaps is false.',
             });
         }
@@ -286,9 +274,9 @@ function evaluateOrderCollisions(patches, severity) {
         const filenames = matches.map((patch) => patch.filename).sort((a, b) => a.localeCompare(b));
         issues.push({
             code: 'order-collision',
-            filename: String(order).padStart(3, '0'),
+            filename: formatPatchOrder(order),
             severity,
-            message: `patchPolicy requires unique numeric orders; order ${String(order).padStart(3, '0')} ` +
+            message: `patchPolicy requires unique numeric orders; order ${formatPatchOrder(order)} ` +
                 `is used by: ${filenames.join(', ')}.`,
         });
     }
@@ -299,7 +287,7 @@ export function evaluatePatchPolicy(config, manifest) {
     const cfg = policy(config);
     if (!cfg)
         return [];
-    const severity = issueSeverity(config);
+    const severity = mutationMode(config) === 'warn' ? 'warning' : 'error';
     const issues = manifest.patches.flatMap((patch) => evaluatePatchMetadata(cfg, patch, severity));
     issues.push(...evaluateOrderCollisions(manifest.patches, severity));
     issues.push(...evaluateGaps(cfg, manifest.patches, severity));
@@ -335,7 +323,7 @@ export function applyRenameMapToManifest(manifest, renameMap) {
 }
 /** Enforces patch policy according to the configured mutation mode. */
 export function enforcePatchPolicy(input) {
-    if (!hasPatchPolicy(input.config))
+    if (policy(input.config) === undefined)
         return;
     const issues = evaluatePatchPolicy(input.config, input.manifest);
     if (issues.length === 0)

package/dist/src/core/patch-source-metadata.d.ts

@@ -1,8 +1,6 @@
 import type { PatchMetadata } from '../types/commands/index.js';
-import type { FirefoxConfig, FirefoxProduct } from '../types/config.js';
+import type { FirefoxConfig } from '../types/config.js';
 /** Metadata fields stamped on new or refreshed patch entries. */
 export declare function buildPatchSourceMetadata(firefox: Pick<FirefoxConfig, 'product' | 'version'>): Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceProduct' | 'sourceVersion'>;
 /** Backward-compatible source version reader for legacy manifests. */
 export declare function getPatchSourceVersion(patch: Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceVersion'>): string;
-/** Backward-compatible source product reader for legacy manifests. */
-export declare function getPatchSourceProduct(patch: Pick<PatchMetadata, 'sourceProduct'>): FirefoxProduct | undefined;

package/dist/src/core/patch-source-metadata.js

@@ -10,7 +10,3 @@ export function buildPatchSourceMetadata(firefox) {
 export function getPatchSourceVersion(patch) {
     return patch.sourceVersion ?? patch.sourceEsrVersion;
 }
-/** Backward-compatible source product reader for legacy manifests. */
-export function getPatchSourceProduct(patch) {
-    return patch.sourceProduct;
-}