@hominis/fireforge 0.45.0 → 0.46.1

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

@@ -1,12 +1,12 @@
 /**
  * Resolves a patch identifier to its manifest entry. Accepts:
  *
- *   1. An ordinal number (e.g. `2`) — matches `PatchMetadata.order`.
- *   2. A full filename with `.patch` suffix (e.g. `002-ui-foo.patch`) —
- *      matches `PatchMetadata.filename`.
- *   3. A filename without the `.patch` suffix — the command appends it
+ *   1. An ordinal number (e.g. `2`), matching `PatchMetadata.order`.
+ *   2. A full filename with `.patch` suffix (e.g. `002-ui-foo.patch`),
+ *      matching `PatchMetadata.filename`.
+ *   3. A filename without the `.patch` suffix. The command appends it
  *      before matching (e.g. `002-ui-foo`).
- *   4. The manifest `name` field (e.g. `furnace-token-override`) — the short
+ *   4. The manifest `name` field (e.g. `furnace-token-override`), the short
  *      logical handle the export workflow stamps onto the patch and the
  *      natural identifier an operator keeps in their notes. The CLI help
  *      says `<name>`, so rejecting it forces the operator to copy the full
@@ -22,14 +22,14 @@ export function resolvePatchIdentifier(identifier, patches) {
         const order = parseInt(identifier, 10);
         return patches.find((p) => p.order === order) ?? null;
     }
-    // Filename lookup — try the input as-is first (covers both the
+    // Filename lookup: try the input as-is first (covers both the
     // full `.patch` form and a bare name, because `endsWith` treats the
     // bare form as a miss and falls through to the appended variant).
     const normalized = identifier.endsWith('.patch') ? identifier : `${identifier}.patch`;
     const byFilename = patches.find((p) => p.filename === normalized || p.filename === identifier);
     if (byFilename)
         return byFilename;
-    // Name-field lookup — the short logical handle stamped into the
+    // Name-field lookup: the short logical handle stamped into the
     // manifest at export time. See function docstring.
     return patches.find((p) => p.name === identifier) ?? null;
 }

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

@@ -92,12 +92,12 @@ function validatePatchMetadata(data, index) {
         throw new Error(`patches[${index}].sourceEsrVersion must be a valid Firefox version string`);
     }
     const filesAffected = rec.stringArray('filesAffected');
-    // Optional fields. These are easy to strip silently — an escape hatch
+    // Optional fields. These are easy to strip silently: an escape hatch
     // that round-trips only through test fixtures mocking
     // `loadPatchesManifest` looks fine while real operator edits to
     // `patches.json` are dropped on every load, so a patch relying on
     // `lintIgnore` to suppress a rule is quietly re-tripped the next time the
-    // manifest validates. Preserve both `lintIgnore` and `tier` here; future
+    // manifest validates. Preserve both `lintIgnore` and `tier` here. Future
     // optional fields follow the same template.
     const lintIgnore = rec.optionalStringArray('lintIgnore');
     const rawTier = rec.raw('tier');
@@ -143,7 +143,7 @@ export function validatePatchesManifest(data) {
     if (!isObject(data)) {
         throw new Error('patches.json must be a JSON object');
     }
-    // A manifest from a NEWER FireForge is not corrupt. The bare "version must
+    // A manifest from a newer FireForge is not corrupt. The bare "version must
     // be 1" this replaced sent the operator looking for damage in a file that
     // only needed a newer build to read it.
     const version = checkDocumentVersion(data, 'version', PATCHES_MANIFEST_VERSION);

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

@@ -1,7 +1,7 @@
 /**
- * Patches manifest — re-exports from focused sub-modules.
+ * Patches manifest: re-exports from focused sub-modules.
  *
- * Callers should continue to import from this module; the internal split
+ * Callers should continue to import from this module. The internal split
  * is an implementation detail.
  */
 export { type PatchManifestConsistencyIssue, rebuildPatchesManifest, recommendManifestRepair, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';

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

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * Patches manifest — re-exports from focused sub-modules.
+ * Patches manifest: re-exports from focused sub-modules.
  *
- * Callers should continue to import from this module; the internal split
+ * Callers should continue to import from this module. The internal split
  * is an implementation detail.
  */
 export { rebuildPatchesManifest, recommendManifestRepair, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';

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"
@@ -24,7 +35,7 @@ export declare function extractOrder(filename: string): number;
  * `Infinity` for a prefix-less filename, which sorts such a patch last and
  * is the right answer for a read: an unparseable name should not crash a
  * status listing. Persisting `Infinity` (or the `0` some call sites used to
- * fall back to) is a different matter — it puts an order in the manifest
+ * fall back to) is a different matter: it puts an order in the manifest
  * that no filename on disk agrees with, and the queue then applies in an
  * order the operator cannot see. Callers here have always just built or
  * looked up a real prefixed filename, so absence is a bug, not input.
@@ -41,7 +52,7 @@ export declare function requirePatchOrder(filename: string): number;
 export interface DiffGitHeader {
     /** Old-side (`a/`) path. */
     sourcePath: string;
-    /** New-side (`b/`) path — the file the patch produces. */
+    /** New-side (`b/`) path: the file the patch produces. */
     targetPath: string;
 }
 /**
@@ -51,8 +62,8 @@ export interface DiffGitHeader {
  * (`diff --git "a/x y" "b/x y"`), and disambiguates the unquoted form for
  * paths that themselves contain ` b/`: for the overwhelmingly common
  * non-rename case the two paths are identical, so a symmetric split
- * (`a/<p> b/<p>`) is tried first — a greedy `a\/.+ b\/(.+)$` splits such
- * lines at the LAST ` b/` and returns a truncated path. Falls back to a
+ * (`a/<p> b/<p>`) is tried first: a greedy `a\/.+ b\/(.+)$` splits such
+ * lines at the last ` b/` and returns a truncated path. Falls back to a
  * non-greedy split for renames.
  *
  * @returns null when the line is not a diff --git header.
@@ -62,7 +73,7 @@ export declare function parseDiffGitHeader(line: string): DiffGitHeader | null;
  * One `diff --git` section of a unified diff, fully structured.
  */
 export interface DiffSection {
-    /** New-side (`b/`) path — the file this section produces. */
+    /** New-side (`b/`) path: the file this section produces. */
     targetPath: string;
     /** Old-side (`a/`) path. */
     sourcePath: string;
@@ -72,21 +83,21 @@ export interface DiffSection {
     isDeletedFile: boolean;
     /**
      * True for binary sections (`GIT binary patch` or `Binary files … differ`).
-     * Binary sections have no parseable hunks; text-oriented consumers must
+     * Binary sections have no parseable hunks. Text-oriented consumers must
      * refuse them rather than treat base85 lines starting with `+` as content.
      */
     isBinary: boolean;
     /**
-     * True ONLY for `GIT binary patch` sections — the body carries a
+     * True only for `GIT binary patch` sections, whose body carries a
      * reconstructable literal/delta payload. False for `Binary files … differ`,
-     * which records THAT the bytes changed but carries none of them and cannot
+     * which records that the bytes changed but carries none of them and cannot
      * be replayed by `git apply`.
      *
      * The distinction is not cosmetic: the stub form still carries a correct
      * `index <old>..<new>` line, so identity checks keyed on {@link indexNewHash}
      * alone happily conclude "the recorded bytes match the live file" for a body
      * that can no longer produce those bytes. Consumers deciding whether a patch
-     * can RECREATE a file must read this flag, never `isBinary` plus a hash.
+     * can recreate a file must read this flag, never `isBinary` plus a hash.
      */
     hasBinaryDelta: boolean;
     /**
@@ -95,14 +106,14 @@ export interface DiffSection {
      * parseable index line (hand-written diffs, `Binary files … differ`).
      */
     indexOldHash?: string;
-    /** New-side blob hash from the `index` line; see {@link indexOldHash}. */
+    /** New-side blob hash from the `index` line. See {@link indexOldHash}. */
     indexNewHash?: string;
     /** Parsed hunks, in file order. Empty for binary or metadata-only sections. */
     hunks: ParsedHunk[];
 }
 /**
- * Parses a unified diff into structured per-file sections — the single
- * shared walker every diff consumer builds on.
+ * Parses a unified diff into structured per-file sections. This is the
+ * single shared walker every diff consumer builds on.
  */
 export declare function parseDiffSections(diffContent: string): DiffSection[];
 /**
@@ -121,7 +132,7 @@ export declare function isNewFileInPatch(patchContent: string, targetFile: strin
 export declare function extractAffectedFiles(diffContent: string): string[];
 /**
  * A single parsed hunk. `noNewlineAtEndOld` / `noNewlineAtEndNew` track the
- * `` marker per side — the marker is a trailing
+ * `` marker per side. The marker is a trailing
  * annotation on the immediately preceding body line, and a `-` precedent
  * sets only the old-side flag, a `+` sets only the new-side flag, and a
  * context ` ` line sets both. Collapsing the two into one boolean makes the

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

@@ -4,13 +4,38 @@ import { assert } from '../utils/assert.js';
  * Pure parsing functions for extracting information from patch files. All
  * functions are synchronous and operate on string content.
  *
- * This module is the ONE unified-diff walker in the codebase. Hand-rolled
+ * 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.
  */
+/** 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"
@@ -32,7 +57,7 @@ export function extractOrder(filename) {
  * `Infinity` for a prefix-less filename, which sorts such a patch last and
  * is the right answer for a read: an unparseable name should not crash a
  * status listing. Persisting `Infinity` (or the `0` some call sites used to
- * fall back to) is a different matter — it puts an order in the manifest
+ * fall back to) is a different matter: it puts an order in the manifest
  * that no filename on disk agrees with, and the queue then applies in an
  * order the operator cannot see. Callers here have always just built or
  * looked up a real prefixed filename, so absence is a bug, not input.
@@ -58,8 +83,8 @@ function unquoteGitPath(quoted) {
     for (let i = 0; i < quoted.length; i++) {
         const ch = quoted[i];
         if (ch !== '\\') {
-            // Plain character — may itself be multi-byte when the diff already
-            // contains raw UTF-8; push its bytes.
+            // Plain character, which may itself be multi-byte when the diff already
+            // contains raw UTF-8. Push its bytes.
             const encoded = Buffer.from(quoted[i] ?? '', 'utf-8');
             for (const b of encoded)
                 bytes.push(b);
@@ -87,8 +112,8 @@ function unquoteGitPath(quoted) {
  * (`diff --git "a/x y" "b/x y"`), and disambiguates the unquoted form for
  * paths that themselves contain ` b/`: for the overwhelmingly common
  * non-rename case the two paths are identical, so a symmetric split
- * (`a/<p> b/<p>`) is tried first — a greedy `a\/.+ b\/(.+)$` splits such
- * lines at the LAST ` b/` and returns a truncated path. Falls back to a
+ * (`a/<p> b/<p>`) is tried first: a greedy `a\/.+ b\/(.+)$` splits such
+ * lines at the last ` b/` and returns a truncated path. Falls back to a
  * non-greedy split for renames.
  *
  * @returns null when the line is not a diff --git header.
@@ -128,10 +153,10 @@ export function parseDiffGitHeader(line) {
  * Splits raw diff content into lines, tolerating CRLF-saved patch files.
  *
  * The distinction matters: a patch file saved with CRLF endings (Windows
- * editor, `core.autocrlf` checkout) has `\r` on EVERY line including
- * structural ones — strip it, or headers, `@@` lines and the
+ * editor, `core.autocrlf` checkout) has `\r` on every line including
+ * structural ones. Strip it, or headers, `@@` lines and the
  * `` marker all fail to match. But an LF patch
- * of a file whose CONTENT is CRLF has `\r` only on payload lines, where it
+ * of a file whose content is CRLF has `\r` only on payload lines, where it
  * is significant and must be preserved. Detect the former by checking the
  * structural lines themselves for a trailing `\r`.
  */
@@ -145,8 +170,8 @@ function splitDiffLines(diffContent) {
     return lines.map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
 }
 /**
- * Parses a unified diff into structured per-file sections — the single
- * shared walker every diff consumer builds on.
+ * Parses a unified diff into structured per-file sections. This is the
+ * single shared walker every diff consumer builds on.
  */
 export function parseDiffSections(diffContent) {
     const sections = [];
@@ -198,7 +223,7 @@ export function parseDiffSections(diffContent) {
                 continue;
             }
             // `git diff --binary` always records full blob hashes here (git
-            // apply requires them); text sections carry abbreviated ones. The
+            // apply requires them). Text sections carry abbreviated ones. The
             // hashes let binary sections be compared by identity when their
             // payload cannot be applied as text.
             const indexMatch = /^index ([0-9a-f]{7,64})\.\.([0-9a-f]{7,64})(?: \d{6})?$/.exec(line);
@@ -229,7 +254,7 @@ export function parseDiffSections(diffContent) {
         if (line === '\') {
             // The marker is an annotation on the immediately preceding body
             // line. Peek the last collected line to decide which side(s) the
-            // annotation applies to — a single boolean cannot represent the
+            // annotation applies to. A single boolean cannot represent the
             // asymmetric case where only one side lacks the trailing newline.
             const previous = currentHunk.lines[currentHunk.lines.length - 1] ?? '';
             if (previous.startsWith('-')) {
@@ -242,12 +267,12 @@ export function parseDiffSections(diffContent) {
                 // Context line: present in both sides, so the trailing-newline
                 // absence applies to both. This is rare (it only happens when
                 // the hunk ends on an unchanged line that itself is the last
-                // line of the file) but real — git emits it.
+                // line of the file) but real: git emits it.
                 currentHunk.noNewlineAtEndOld = true;
                 currentHunk.noNewlineAtEndNew = true;
             }
             // If the marker appears with no preceding body line (malformed
-            // diff), leave both flags false — the downstream apply logic
+            // diff), leave both flags false. The downstream apply logic
             // will still produce a defined result.
             continue;
         }

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-registration-refs.d.ts

@@ -8,7 +8,7 @@
  * clean" for the broken queue. This module provides a pattern-scoped scan so
  * `verify` can cross-check registrations against available file bodies.
  *
- * The scan is deliberately narrow: it only matches component-shaped
+ * The scan is narrow on purpose: it only matches component-shaped
  * references (widget tag names, locale fluent names). Unrelated jar.mn or
  * customElements.js edits pass through without spurious warnings.
  */
@@ -28,11 +28,11 @@ export interface PatchRegistrationReference {
 }
 /**
  * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch ADDS a registration for.
+ * component-shaped engine paths that the patch adds a registration for.
  *
- * Returns the empty array when no registration hunks are present OR
+ * Returns the empty array when no registration hunks are present, or
  * when the registration hunks do not mention any component-shaped
- * paths — that leaves the scan silent on the vast majority of patches
+ * paths. That leaves the scan silent on the vast majority of patches
  * (branding tweaks, behavioural fixes, module additions) so it only
  * fires when a furnace-managed component is being newly registered.
  *

package/dist/src/core/patch-registration-refs.js

@@ -9,7 +9,7 @@
  * clean" for the broken queue. This module provides a pattern-scoped scan so
  * `verify` can cross-check registrations against available file bodies.
  *
- * The scan is deliberately narrow: it only matches component-shaped
+ * The scan is narrow on purpose: it only matches component-shaped
  * references (widget tag names, locale fluent names). Unrelated jar.mn or
  * customElements.js edits pass through without spurious warnings.
  */
@@ -23,11 +23,11 @@ const REGISTRATION_FILE_PATHS = new Set([
 ]);
 /**
  * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch ADDS a registration for.
+ * component-shaped engine paths that the patch adds a registration for.
  *
- * Returns the empty array when no registration hunks are present OR
+ * Returns the empty array when no registration hunks are present, or
  * when the registration hunks do not mention any component-shaped
- * paths — that leaves the scan silent on the vast majority of patches
+ * paths. That leaves the scan silent on the vast majority of patches
  * (branding tweaks, behavioural fixes, module additions) so it only
  * fires when a furnace-managed component is being newly registered.
  *
@@ -38,7 +38,7 @@ export function collectPatchRegistrationReferences(patchBody) {
         return [];
     const refs = [];
     // Key the file state off the `b/` path because that names the target
-    // side and is stable against renames. Only real hunk adds count —
+    // side and is stable against renames. Only real hunk adds count.
     // parseDiffSections has already filtered out header/metadata lines.
     for (const section of parseDiffSections(patchBody)) {
         if (!REGISTRATION_FILE_PATHS.has(section.targetPath))
@@ -59,7 +59,7 @@ export function collectPatchRegistrationReferences(patchBody) {
 }
 /**
  * Per-source extractor. Each registration file has a distinct syntactic
- * shape; we scope the match to that file so a jar.mn regex does not
+ * shape. We scope the match to that file so a jar.mn regex does not
  * accidentally match a customElements.js line.
  */
 function extractTargetPathsFromRegistrationLine(sourceFile, added) {
@@ -68,7 +68,7 @@ function extractTargetPathsFromRegistrationLine(sourceFile, added) {
         //   `   content/global/elements/moz-qa-panel.mjs  (widgets/moz-qa-panel/moz-qa-panel.mjs)`
         // The parenthesised second half is the repo-relative path Firefox's
         // packaging system reads. Widget registrations always live under
-        // `widgets/<tag>/<file>` — the enclosing tree is
+        // `widgets/<tag>/<file>`, and the enclosing tree is
         // `toolkit/content/widgets/`. Reconstruct the engine-relative
         // target path so callers can check it against patch bodies.
         const widgetMatch = /\(\s*(widgets\/[^\s)]+)\s*\)/.exec(added);

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;
-}

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

@@ -5,29 +5,29 @@
 /**
  * Extracts the complete file content from a "new file" patch given a raw
  * diff string already in memory. Callers with a patch file path should
- * prefer {@link extractNewFileContent}; this helper exists for code paths
+ * prefer {@link extractNewFileContent}. This helper exists for code paths
  * that already hold the diff (e.g. the in-flight export planner) and do
  * not want to round-trip through the filesystem.
  *
  * @param diff - Raw unified-diff content
  * @param targetFile - Optional target file to scope extraction to
  * @returns The file content that the patch would create
- * @throws PatchError for binary sections — a `GIT binary patch` payload is
+ * @throws PatchError for binary sections. A `GIT binary patch` payload is
  *   base85 (whose alphabet includes `+`), so "extract the + lines" would
  *   silently write garbage text over a binary target. Callers must treat
  *   binary new-file conflicts as unresolvable rather than auto-resolving.
  */
 export declare function extractNewFileContentFromDiff(diff: string, targetFile?: string): string;
 /**
- * Projects every TEXT new file a diff creates into a path → content map, for
+ * Projects every text new file a diff creates into a path → content map, for
  * the cross-patch lint projections that build a synthetic patch-queue entry.
  *
- * Binary new files are SKIPPED rather than refused. The map feeds only the
- * forward-import rule, which scans content for import statements — a binary
- * blob authors none, so omitting it contributes exactly what including it
- * would. Refusing instead (which is what
+ * Binary new files are skipped rather than refused. The map feeds only the
+ * forward-import rule, which scans content for import statements, and a
+ * binary blob authors none, so omitting it contributes exactly what
+ * including it would. Refusing instead (which is what
  * {@link extractNewFileContentFromDiff} correctly does for a caller that
- * named ONE file) made vendoring a new binary impossible: every projection
+ * named one file) made vendoring a new binary impossible: every projection
  * site fed it every detected new file, so `export --order`, `re-export
  * --scan --scan-file`, `patch move-files-into` and `patch split` all died on
  * a file the export half had just written a valid `GIT binary patch` for.
@@ -48,14 +48,6 @@ export declare function buildNewFileTextProjection(diff: string): Map<string, st
  * @returns The file content that the patch would create
  */
 export declare function extractNewFileContent(patchPath: string, targetFile?: string): Promise<string>;
-/**
- * Applies a patch's changes to content.
- * @param content - Original content (null for new files)
- * @param patchPath - Path to the patch file
- * @param targetFile - The file path within the patch
- * @returns Modified content
- */
-export declare function applyPatchToContent(content: string | null, patchPath: string, targetFile: string): Promise<string>;
 /**
  * Applies an already-read patch body to content. Batched callers that hold
  * many (patch, file) pairs use this to read each patch body once instead of