@hominis/fireforge 0.45.0 → 0.46.0

package/dist/src/core/moz-manifest-rules.js

@@ -3,6 +3,7 @@ import { basename, join } from 'node:path';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { escapeRegex } from '../utils/regex.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { registerBrowserContent, registerFireForgeModule, registerSharedCSS, registerTestManifest, registerToolkitWidget, } from './moz-manifest-register.js';
@@ -84,13 +85,30 @@ export function getRules(binaryName, createManifest = false) {
         },
     ];
 }
-async function isSharedCSSRegistered(engineDir, fileName) {
-    const manifestPath = join(engineDir, 'browser/themes/shared/jar.inc.mn');
+/**
+ * Reads an engine manifest and reports whether it contains any of `needles`.
+ *
+ * The five registration probes below share this shape: resolve the manifest
+ * relative to the engine, refuse with the manifest's own path when it is
+ * missing, then substring-match the entry each registrar writes.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param manifestRel - Engine-relative manifest path (forward slashes; also
+ *   the path named in the refusal message)
+ * @param needles - Entry forms that count as registered
+ * @returns True when the manifest contains at least one needle
+ * @throws GeneralError when the manifest does not exist
+ */
+async function manifestIncludes(engineDir, manifestRel, needles) {
+    const manifestPath = join(engineDir, manifestRel);
     if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: browser/themes/shared/jar.inc.mn');
+        throw new GeneralError(`Manifest not found: ${manifestRel}`);
     }
-    const name = basename(fileName, '.css');
     const content = await readText(manifestPath);
+    return needles.some((needle) => content.includes(needle));
+}
+async function isSharedCSSRegistered(engineDir, fileName) {
+    const name = basename(fileName, '.css');
     // `register` writes the canonical `skin/classic/browser/<name>.css` form;
     // `furnace chrome-doc create` writes a `content/browser/<name>.css` entry
     // because the CSS is loaded by a chrome document via a `chrome://browser/
@@ -98,40 +116,26 @@ async function isSharedCSSRegistered(engineDir, fileName) {
     // chrome-doc scaffolder are not flagged as "potentially unregistered" by
     // `status` and so a re-run of `register` against the same file recognises
     // the existing entry instead of proposing a duplicate.
-    return (content.includes(`skin/classic/browser/${name}.css`) ||
-        content.includes(`content/browser/${name}.css`));
+    return manifestIncludes(engineDir, 'browser/themes/shared/jar.inc.mn', [
+        `skin/classic/browser/${name}.css`,
+        `content/browser/${name}.css`,
+    ]);
 }
 async function isBrowserContentRegistered(engineDir, fileName) {
-    const manifestPath = join(engineDir, 'browser/base/jar.mn');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: browser/base/jar.mn');
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`content/browser/${fileName}`);
+    return manifestIncludes(engineDir, 'browser/base/jar.mn', [`content/browser/${fileName}`]);
 }
 async function isTestManifestRegistered(engineDir, testDir) {
-    const manifestPath = join(engineDir, 'browser/base/moz.build');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: browser/base/moz.build');
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`content/test/${testDir}/browser.toml`);
+    return manifestIncludes(engineDir, 'browser/base/moz.build', [
+        `content/test/${testDir}/browser.toml`,
+    ]);
 }
 async function isFireForgeModuleRegistered(engineDir, fileName, moduleDir) {
-    const manifestPath = join(engineDir, moduleDir, 'moz.build');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError(`Manifest not found: ${moduleDir}/moz.build`);
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`"${fileName}"`);
+    return manifestIncludes(engineDir, `${moduleDir}/moz.build`, [`"${fileName}"`]);
 }
 async function isToolkitWidgetRegistered(engineDir, _tagName, fileName) {
-    const manifestPath = join(engineDir, 'toolkit/content/jar.mn');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: toolkit/content/jar.mn');
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`content/global/elements/${fileName}`);
+    return manifestIncludes(engineDir, 'toolkit/content/jar.mn', [
+        `content/global/elements/${fileName}`,
+    ]);
 }
 /**
  * Checks if a file path matches any known registrable pattern.
@@ -140,7 +144,7 @@ async function isToolkitWidgetRegistered(engineDir, _tagName, fileName) {
  * @returns True if the file matches a known registration pattern
  */
 export function matchesRegistrablePattern(filePath, binaryName) {
-    const normalized = filePath.replace(/\\/g, '/');
+    const normalized = normalizePathSlashes(filePath);
     const rules = getRules(binaryName);
     return rules.some((rule) => rule.pattern.test(normalized));
 }
@@ -197,7 +201,7 @@ export async function isFileRegistered(root, filePath) {
     const { engine: engineDir } = getProjectPaths(root);
     const config = await loadConfig(root);
     const rules = getRules(config.binaryName);
-    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPath = normalizePathSlashes(filePath);
     for (const rule of rules) {
         const match = normalizedPath.match(rule.pattern);
         if (match) {
@@ -237,7 +241,7 @@ export async function registerFile(root, filePath, dryRun = false, after, option
     const config = await loadConfig(root);
     const rules = getRules(config.binaryName, options.createManifest === true);
     // Normalize path separators
-    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPath = normalizePathSlashes(filePath);
     for (const rule of rules) {
         const match = normalizedPath.match(rule.pattern);
         if (match) {

package/dist/src/core/patch-apply-fuzz.js

@@ -42,13 +42,13 @@ const GIT_DEFAULT_CONTEXT = 3;
  */
 export async function applyPatchWithFuzz(patchPath, engineDir, maxFuzz = 3) {
     if (!Number.isInteger(maxFuzz) || maxFuzz < 0) {
-        throw new InvalidArgumentError(`maxFuzz must be a non-negative integer, got ${String(maxFuzz)}.`, 'maxFuzz');
+        throw new InvalidArgumentError(`maxFuzz must be a non-negative integer, got ${maxFuzz}.`, 'maxFuzz');
     }
     await ensureGit();
     // Try exact match first, then escalate context reduction.
     const maxSteps = Math.min(maxFuzz, GIT_DEFAULT_CONTEXT);
     for (let step = 0; step <= maxSteps; step++) {
-        const contextArgs = step > 0 ? [`-C${String(GIT_DEFAULT_CONTEXT - step)}`] : [];
+        const contextArgs = step > 0 ? [`-C${GIT_DEFAULT_CONTEXT - step}`] : [];
         const check = await exec('git', ['apply', '--check', ...contextArgs, '--', patchPath], {
             cwd: engineDir,
         });
@@ -59,12 +59,12 @@ export async function applyPatchWithFuzz(patchPath, engineDir, maxFuzz = 3) {
             });
             if (apply.exitCode === 0) {
                 if (step > 0) {
-                    verbose(`Patch applied with reduced context (-C${String(GIT_DEFAULT_CONTEXT - step)}): ${patchPath}`);
+                    verbose(`Patch applied with reduced context (-C${GIT_DEFAULT_CONTEXT - step}): ${patchPath}`);
                 }
                 return { success: true, fuzzFactor: step };
             }
             // Unlikely: --check passed but apply failed; fall through to next step
-            verbose(`git apply -C${String(GIT_DEFAULT_CONTEXT - step)} --check passed but apply failed: ${apply.stderr.trim()}`);
+            verbose(`git apply -C${GIT_DEFAULT_CONTEXT - step} --check passed but apply failed: ${apply.stderr.trim()}`);
         }
     }
     // All context-reduction levels failed → generate .rej files for manual resolution

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

@@ -4,10 +4,9 @@
  */
 import type { ImportSummary, PatchInfo, PatchMetadata } from '../types/commands/index.js';
 export { PatchError } from '../errors/patch.js';
-export { countPatches, discoverPatches, getAllTargetFilesFromPatch, getTargetFileFromPatch, isNewFilePatch, } from './patch-files.js';
+export { countPatches, discoverPatches } from './patch-files.js';
 export { withPatchDirectoryLock } from './patch-lock.js';
-export { extractAffectedFiles, extractOrder, isNewFileInPatch } from './patch-parse.js';
-export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
+export { extractAffectedFiles } from './patch-parse.js';
 /**
  * Options for {@link applyPatchesWithContinue}.
  */
@@ -47,10 +46,10 @@ export declare function matchesUntilFilename(patchFilename: string, needle: stri
  * on the first failure to keep the engine directory in a clean state.
  * @param patchesDir - Path to the patches directory
  * @param engineDir - Path to the engine directory
- * @param optionsOrContinue - Options object, or the legacy continueOnFailure boolean
+ * @param options - Application options
  * @returns Import summary with all results
  */
-export declare function applyPatchesWithContinue(patchesDir: string, engineDir: string, optionsOrContinue?: ApplyPatchesOptions | boolean): Promise<ImportSummary>;
+export declare function applyPatchesWithContinue(patchesDir: string, engineDir: string, options?: ApplyPatchesOptions): Promise<ImportSummary>;
 /**
  * Batched patched-content computation shared by status classification,
  * import's unmanaged-dirty guard, and discard baseline planning.

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

@@ -11,17 +11,16 @@ import { pathExists, readText, writeFileAtomic, writeText } from '../utils/fs.js
 import { verbose } from '../utils/logger.js';
 import { isContainedRelativePath } from '../utils/paths.js';
 import { applyPatchIdempotent, reversePatch } from './git.js';
-import { getFileContentFromHead } from './git-file-ops.js';
+import { getFileContentAtRef } from './git-file-ops.js';
 import { discoverPatches } from './patch-files.js';
 import { loadPatchesManifest } from './patch-manifest.js';
 import { extractAffectedFiles, extractConflictingFiles, isNewFileInPatch, parseDiffSections, } from './patch-parse.js';
 import { applyPatchTextToContent, extractNewFileContentFromDiff } from './patch-transform.js';
 // Re-export from split modules so existing import sites continue working
 export { PatchError } from '../errors/patch.js';
-export { countPatches, discoverPatches, getAllTargetFilesFromPatch, getTargetFileFromPatch, isNewFilePatch, } from './patch-files.js';
+export { countPatches, discoverPatches } from './patch-files.js';
 export { withPatchDirectoryLock } from './patch-lock.js';
-export { extractAffectedFiles, extractOrder, isNewFileInPatch } from './patch-parse.js';
-export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
+export { extractAffectedFiles } from './patch-parse.js';
 /**
  * Applies a single patch.
  *
@@ -272,15 +271,10 @@ export function matchesUntilFilename(patchFilename, needle) {
  * on the first failure to keep the engine directory in a clean state.
  * @param patchesDir - Path to the patches directory
  * @param engineDir - Path to the engine directory
- * @param optionsOrContinue - Options object, or the legacy continueOnFailure boolean
+ * @param options - Application options
  * @returns Import summary with all results
  */
-export async function applyPatchesWithContinue(patchesDir, engineDir, optionsOrContinue = false) {
-    // Accept both the legacy boolean positional and the new options object so
-    // existing call sites (tests and rebase) keep working without a rewrite.
-    const options = typeof optionsOrContinue === 'boolean'
-        ? { continueOnFailure: optionsOrContinue }
-        : optionsOrContinue;
+export async function applyPatchesWithContinue(patchesDir, engineDir, options = {}) {
     const continueOnFailure = options.continueOnFailure ?? false;
     const untilFilename = options.untilFilename;
     const patches = await discoverPatches(patchesDir);
@@ -406,7 +400,7 @@ export async function createPatchedContentContext(patchesDir, engineDir) {
         getAffectingPatches,
         readPatchBody,
         computePatched: async (filePath) => {
-            let content = await getFileContentFromHead(engineDir, filePath);
+            let content = await getFileContentAtRef(engineDir, filePath);
             for (const patch of getAffectingPatches(filePath)) {
                 content = applyPatchTextToContent(content, await readPatchBody(patch), filePath);
             }

package/dist/src/core/patch-export-coverage.d.ts

@@ -2,15 +2,6 @@
  * Patch coverage and supersession helpers used by export planning.
  */
 import type { PatchInfo, PatchMetadata } from '../types/commands/index.js';
-/**
- * Finds patches that are completely superseded by newer patches.
- * A patch is superseded if all its affected files are covered by newer patches.
- * @param patchesDir - Path to the patches directory
- * @param newPatchFiles - Files affected by the new patch
- * @param excludeFilename - Filename to exclude from results (the new patch itself)
- * @returns Superseded patches
- */
-export declare function findSupersededPatches(patchesDir: string, newPatchFiles: string[], excludeFilename?: string): Promise<PatchInfo[]>;
 /**
  * Report whether a patch is fully covered by a new export, and which of its
  * files caused the coverage.

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

@@ -2,37 +2,8 @@
 /**
  * Patch coverage and supersession helpers used by export planning.
  */
-import { discoverPatches, isNewFilePatch } from './patch-apply.js';
+import { discoverPatches } from './patch-apply.js';
 import { loadPatchesManifest } from './patch-manifest.js';
-/**
- * Finds patches that are completely superseded by newer patches.
- * A patch is superseded if all its affected files are covered by newer patches.
- * @param patchesDir - Path to the patches directory
- * @param newPatchFiles - Files affected by the new patch
- * @param excludeFilename - Filename to exclude from results (the new patch itself)
- * @returns Superseded patches
- */
-export async function findSupersededPatches(patchesDir, newPatchFiles, excludeFilename) {
-    const manifest = await loadPatchesManifest(patchesDir);
-    if (!manifest)
-        return [];
-    const patches = await discoverPatches(patchesDir);
-    const superseded = [];
-    for (const metadata of manifest.patches) {
-        if (excludeFilename && metadata.filename === excludeFilename)
-            continue;
-        if (metadata.filesAffected.length === 1) {
-            const affectedFile = metadata.filesAffected[0];
-            if (affectedFile && newPatchFiles.includes(affectedFile)) {
-                const patch = patches.find((p) => p.filename === metadata.filename);
-                if (patch && (await isNewFilePatch(patch.path))) {
-                    superseded.push(patch);
-                }
-            }
-        }
-    }
-    return superseded;
-}
 /**
  * Checks whether a patch is fully covered by a new export.
  * A patch is fully covered when every file it affects is present in the new export.

package/dist/src/core/patch-export-update.d.ts

@@ -13,6 +13,22 @@ export interface UpdatePatchPolicyGate {
     command: string;
     forceUnsafe?: boolean;
 }
+export interface UpdatePatchAndMetadataOptions {
+    /** Patch directory holding the body and `patches.json`. */
+    patchesDir: string;
+    /** Patch file to rewrite. */
+    filename: string;
+    /** New patch body; an identical body skips the write. */
+    newContent: string;
+    /** Manifest-row fields to merge into the patch's metadata. */
+    updates: Partial<PatchMetadata>;
+    /** Hook run under the lock after the mutation succeeds. */
+    onCommitted?: UpdatePatchCommittedHook | undefined;
+    /** Policy gate run against the under-lock projected manifest. */
+    policyGate?: UpdatePatchPolicyGate | undefined;
+    /** Wait budget and command name for the patch directory lock. */
+    lockOptions?: PatchDirectoryLockOptions | undefined;
+}
 /**
  * Updates a patch file body and its manifest row under the same patch
  * directory lock. Intended for commands like `re-export --files` where the
@@ -26,7 +42,8 @@ export interface UpdatePatchPolicyGate {
  * unexpected rewrite in `git status`. Metadata still moves either way — only
  * the redundant byte-for-byte write is elided.
  *
+ * @param options - See {@link UpdatePatchAndMetadataOptions}
  * @returns True when the patch body on disk changed, false when it was
  *   already byte-identical to the new content.
  */
-export declare function updatePatchAndMetadata(patchesDir: string, filename: string, newContent: string, updates: Partial<PatchMetadata>, onCommitted?: UpdatePatchCommittedHook, policyGate?: UpdatePatchPolicyGate, lockOptions?: PatchDirectoryLockOptions): Promise<boolean>;
+export declare function updatePatchAndMetadata(options: UpdatePatchAndMetadataOptions): Promise<boolean>;

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

@@ -5,7 +5,6 @@ import { toError } from '../utils/errors.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { withPatchDirectoryLock } from './patch-apply.js';
-import { normalizePatchArtifact } from './patch-artifact-normalize.js';
 import { loadPatchesManifestForWrite, mutatePatchRowsInManifest } from './patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
 /**
@@ -21,10 +20,12 @@ import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
  * unexpected rewrite in `git status`. Metadata still moves either way — only
  * the redundant byte-for-byte write is elided.
  *
+ * @param options - See {@link UpdatePatchAndMetadataOptions}
  * @returns True when the patch body on disk changed, false when it was
  *   already byte-identical to the new content.
  */
-export async function updatePatchAndMetadata(patchesDir, filename, newContent, updates, onCommitted, policyGate, lockOptions = {}) {
+export async function updatePatchAndMetadata(options) {
+    const { patchesDir, filename, newContent, updates, onCommitted, policyGate, lockOptions = {}, } = options;
     return withPatchDirectoryLock(patchesDir, async () => {
         const manifest = await loadPatchesManifestForWrite(patchesDir);
         if (!manifest) {
@@ -49,7 +50,7 @@ export async function updatePatchAndMetadata(patchesDir, filename, newContent, u
                 forceUnsafe: policyGate.forceUnsafe === true,
             });
         }
-        const normalized = normalizePatchArtifact(newContent);
+        const normalized = newContent;
         const bodyChanged = normalized !== originalContent;
         let patchWritten = false;
         try {

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

@@ -2,9 +2,19 @@ import type { PatchCategory, PatchesManifest, PatchInfo, PatchMetadata } from '.
 import type { FireForgeConfig } from '../types/config.js';
 import { type SupersedeCoverageDetail } from './patch-export-coverage.js';
 import type { PatchDirectoryLockOptions } from './patch-lock.js';
-export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, findSupersededPatches, isPatchFullyCovered, type SupersedeCoverageDetail, } from './patch-export-coverage.js';
+export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 export { mutatePatchMetadata, updatePatchMetadata } from './patch-export-metadata.js';
 export { updatePatchAndMetadata } from './patch-export-update.js';
+/**
+ * Projects the planning subset out of a wider export input (commit input,
+ * dry-run preview input) — the fields `planExport` /
+ * `computeExportPlanUnderLock` read. Optional fields are copied only when
+ * present so the plan input never carries explicit `undefined` keys, which
+ * would otherwise leak into the written metadata via spread. The commit
+ * path and the dry-run preview both go through this one projection so
+ * they cannot drift field by field.
+ */
+export declare function buildPlanExportInput(input: PlanExportInput): PlanExportInput;
 /**
  * Gets the next patch number for a new patch.
  * @param patchesDir - Path to the patches directory
@@ -91,26 +101,6 @@ export interface CommitExportedPatchResult {
  * to filename allocation or supersede detection lands in both automatically.
  */
 export declare function commitExportedPatch(input: CommitExportedPatchInput): Promise<CommitExportedPatchResult>;
-/**
- * Parses a patch filename to extract order, category, and name.
- * Supports both new format (001-category-name.patch) and legacy (001-name.patch).
- */
-export declare function parseFilename(filename: string): {
-    order: number;
-    category: PatchCategory | null;
-    name: string;
-};
-/**
- * Finds an existing patch that contains the specified file.
- * Returns the most recent (highest order) patch if multiple exist.
- * @param patchesDir - Path to the patches directory
- * @param filePath - File path to search for
- * @returns The patch info and metadata, or null if not found
- */
-export declare function findExistingPatchForFile(patchesDir: string, filePath: string): Promise<{
-    patch: PatchInfo;
-    metadata: PatchMetadata;
-} | null>;
 /**
  * Updates the content of a patch file.
  * @param patchPath - Path to the patch file

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

@@ -3,17 +3,39 @@ import { join } from 'node:path';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
-import { PATCH_CATEGORIES } from '../utils/validation.js';
 import { discoverPatches, withPatchDirectoryLock } from './patch-apply.js';
-import { normalizePatchArtifact } from './patch-artifact-normalize.js';
 import { findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
-import { addPatchToManifest, findPatchesAffectingFile, loadPatchesManifestForWrite, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
-import { requirePatchOrder } from './patch-parse.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';
-export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, findSupersededPatches, isPatchFullyCovered, } from './patch-export-coverage.js';
+export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
 import { escapeRegex } from '../utils/regex.js';
 export { mutatePatchMetadata, updatePatchMetadata } from './patch-export-metadata.js';
 export { updatePatchAndMetadata } from './patch-export-update.js';
+/**
+ * Projects the planning subset out of a wider export input (commit input,
+ * dry-run preview input) — the fields `planExport` /
+ * `computeExportPlanUnderLock` read. Optional fields are copied only when
+ * present so the plan input never carries explicit `undefined` keys, which
+ * would otherwise leak into the written metadata via spread. The commit
+ * path and the dry-run preview both go through this one projection so
+ * they cannot drift field by field.
+ */
+export function buildPlanExportInput(input) {
+    return {
+        patchesDir: input.patchesDir,
+        category: input.category,
+        name: input.name,
+        description: input.description,
+        filesAffected: input.filesAffected,
+        sourceEsrVersion: input.sourceEsrVersion,
+        ...(input.sourceProduct !== undefined ? { sourceProduct: input.sourceProduct } : {}),
+        ...(input.sourceVersion !== undefined ? { sourceVersion: input.sourceVersion } : {}),
+        ...(input.tier !== undefined ? { tier: input.tier } : {}),
+        ...(input.lintIgnore !== undefined ? { lintIgnore: input.lintIgnore } : {}),
+        ...(input.config !== undefined ? { config: input.config } : {}),
+    };
+}
 /**
  * Gets the next patch number for a new patch.
  * @param patchesDir - Path to the patches directory
@@ -110,19 +132,7 @@ export async function getNextPatchFilename(patchesDir, category, name) {
  */
 export async function commitExportedPatch(input) {
     return withPatchDirectoryLock(input.patchesDir, async () => {
-        const plan = await computeExportPlanUnderLock({
-            patchesDir: input.patchesDir,
-            category: input.category,
-            name: input.name,
-            description: input.description,
-            filesAffected: input.filesAffected,
-            sourceEsrVersion: input.sourceEsrVersion,
-            ...(input.sourceProduct !== undefined ? { sourceProduct: input.sourceProduct } : {}),
-            ...(input.sourceVersion !== undefined ? { sourceVersion: input.sourceVersion } : {}),
-            ...(input.tier !== undefined ? { tier: input.tier } : {}),
-            ...(input.lintIgnore !== undefined ? { lintIgnore: input.lintIgnore } : {}),
-            ...(input.config !== undefined ? { config: input.config } : {}),
-        });
+        const plan = await computeExportPlanUnderLock(buildPlanExportInput(input));
         if (input.config !== undefined) {
             enforcePatchPolicy({
                 config: input.config,
@@ -140,7 +150,20 @@ export async function commitExportedPatch(input) {
             }
         }
         try {
-            await writeText(patchPath, normalizePatchArtifact(input.diff));
+            // Patch bodies are written byte-for-byte as git produced them, including the
+            // single-space rendering of a blank context line.
+            //
+            // Do NOT add a whitespace-trimming pass here or at any other write site.
+            // Stripping marker lines whose payload is pure whitespace (`/^[ +-]\s+$/` →
+            // bare marker) corrupts real content: Firefox sources contain whitespace-only
+            // lines, so a ` `/`-` line whose payload was two spaces no longer matches the
+            // pristine tree and the freshly exported patch fails `git apply --check`,
+            // while a `+` line silently changes what the patch produces. The repository
+            // whitespace check already exempts `patches/*.patch`
+            // (scripts/check-worktree-whitespace.mjs), and the byte-fidelity contract is
+            // pinned end-to-end by `git-diff-latin1-roundtrip.test.ts` and
+            // `re-export.integration.test.ts`.
+            await writeText(patchPath, input.diff);
             await addPatchToManifest(input.patchesDir, plan.metadata, plan.supersededPatches.map((p) => p.filename));
             for (const oldPatch of plan.supersededPatches) {
                 await removeFile(oldPatch.path);
@@ -188,58 +211,13 @@ export async function commitExportedPatch(input) {
         };
     }, input.lockOptions ?? {});
 }
-/**
- * Parses a patch filename to extract order, category, and name.
- * Supports both new format (001-category-name.patch) and legacy (001-name.patch).
- */
-export function parseFilename(filename) {
-    // New format: 001-ui-sidebar.patch
-    const newMatch = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(filename);
-    if (newMatch?.[1] && newMatch[2] && newMatch[3]) {
-        const orderStr = newMatch[1];
-        const category = newMatch[2];
-        const name = newMatch[3];
-        if (PATCH_CATEGORIES.includes(category)) {
-            return {
-                order: parseInt(orderStr, 10),
-                category,
-                name,
-            };
-        }
-    }
-    // Legacy format: 001-name.patch
-    const legacyMatch = /^(\d+)-(.+)\.patch$/.exec(filename);
-    if (legacyMatch?.[1] && legacyMatch[2]) {
-        return {
-            order: parseInt(legacyMatch[1], 10),
-            category: null,
-            name: legacyMatch[2],
-        };
-    }
-    return { order: Infinity, category: null, name: filename };
-}
-/**
- * Finds an existing patch that contains the specified file.
- * Returns the most recent (highest order) patch if multiple exist.
- * @param patchesDir - Path to the patches directory
- * @param filePath - File path to search for
- * @returns The patch info and metadata, or null if not found
- */
-export async function findExistingPatchForFile(patchesDir, filePath) {
-    const affectingPatches = await findPatchesAffectingFile(patchesDir, filePath);
-    if (affectingPatches.length === 0) {
-        return null;
-    }
-    // Return the most recent (highest order) patch
-    return affectingPatches[affectingPatches.length - 1] ?? null;
-}
 /**
  * Updates the content of a patch file.
  * @param patchPath - Path to the patch file
  * @param newContent - New patch content
  */
 export async function updatePatch(patchPath, newContent) {
-    await writeText(patchPath, normalizePatchArtifact(newContent));
+    await writeText(patchPath, newContent);
 }
 /**
  * Internal planning helper. Does NOT take the patch directory lock — the
@@ -259,7 +237,7 @@ async function computeExportPlanUnderLock(input) {
         ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category)
         : null;
     const patchFilename = policyOrder !== null
-        ? `${String(policyOrder).padStart(3, '0')}-${input.category}-${patchNameSlug(input.name, input.category)}.patch`
+        ? `${formatPatchOrder(policyOrder)}-${input.category}-${patchNameSlug(input.name, input.category)}.patch`
         : await getNextPatchFilename(input.patchesDir, input.category, input.name);
     const patchPath = join(input.patchesDir, patchFilename);
     const metadata = {

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

@@ -3,10 +3,6 @@ import type { PatchInfo } from '../types/commands/index.js';
 export declare function discoverPatches(patchesDir: string): Promise<PatchInfo[]>;
 /** Counts the patch files currently present in a patch directory. */
 export declare function countPatches(patchesDir: string): Promise<number>;
-/** Checks whether a patch creates a new file rather than modifying an existing one. */
-export declare function isNewFilePatch(patchPath: string): Promise<boolean>;
-/** Returns the first target file path referenced by a patch, if any. */
-export declare function getTargetFileFromPatch(patchPath: string): Promise<string | null>;
 /**
  * Returns all target file paths referenced by a multi-file patch.
  *

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

@@ -24,17 +24,6 @@ export async function countPatches(patchesDir) {
     const patches = await discoverPatches(patchesDir);
     return patches.length;
 }
-/** Checks whether a patch creates a new file rather than modifying an existing one. */
-export async function isNewFilePatch(patchPath) {
-    const content = await readText(patchPath);
-    return content.includes('new file mode') && content.includes('--- /dev/null');
-}
-/** Returns the first target file path referenced by a patch, if any. */
-export async function getTargetFileFromPatch(patchPath) {
-    const content = await readText(patchPath);
-    const match = /^\+\+\+ b\/(.+)$/m.exec(content);
-    return match?.[1] ?? null;
-}
 /**
  * Returns all target file paths referenced by a multi-file patch.
  *

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

@@ -21,20 +21,14 @@
  * cross-patch lint graph.
  */
 import type { PatchLintIssue } from '../types/commands/index.js';
+import type { PatchQueueBodyEntry, PatchQueueView } from './patch-lint-queue-types.js';
 /**
- * The slice of a queue entry this rule reads. Declared structurally rather
- * than importing `PatchQueueEntry` from `patch-lint-cross.ts`, which imports
- * this module back — the local shape keeps the dependency edge one-way and
- * `dpdm` clean, matching `patch-lint-module-registration.ts`.
+ * Queue view accepted by {@link lintPatchQueueBinaryBodies}. Described
+ * structurally rather than by importing `PatchQueueContext` from
+ * `patch-lint-cross.ts`, which imports this module back — the shared leaf
+ * type keeps the dependency edge one-way and `dpdm` clean.
  */
-interface BinaryBodyQueueEntry {
-    filename: string;
-    diff: string;
-}
-/** Queue view accepted by {@link lintPatchQueueBinaryBodies}. */
-interface BinaryBodyQueueContext {
-    entries: readonly BinaryBodyQueueEntry[];
-}
+type BinaryBodyQueueContext = PatchQueueView<PatchQueueBodyEntry>;
 /** Lint check identifier emitted by {@link lintPatchQueueBinaryBodies}. */
 export declare const BINARY_BODY_CHECK = "binary-body-not-reconstructable";
 /**

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

@@ -58,5 +58,21 @@ export interface CachedPerPatchLint {
  * is compared explicitly rather than trusted to the key.
  */
 export declare function getCachedPerPatchLintIssues(cache: PerPatchLintCacheFile, patchFilename: string, key: string, lintIgnore?: Iterable<string>): CachedPerPatchLint | undefined;
+export interface SetCachedPerPatchLintIssuesInput {
+    /** Cache file to mutate in place. */
+    cache: PerPatchLintCacheFile;
+    /** Patch the payload belongs to; also the cache entry key. */
+    patchFilename: string;
+    /** Fingerprint the payload is valid for. */
+    key: string;
+    /** Reported issues, stored as copies. */
+    issues: PatchLintIssue[];
+    /** Issues suppressed by `lintIgnore`, stored as copies. */
+    suppressed: PatchLintIssue[];
+    /** Line count the run measured. */
+    lineCount: number;
+    /** Suppression ids in force for the run, normalized on store. */
+    lintIgnore?: Iterable<string> | undefined;
+}
 /** Stores the per-patch lint payload after a successful lint calculation. */
-export declare function setCachedPerPatchLintIssues(cache: PerPatchLintCacheFile, patchFilename: string, key: string, issues: PatchLintIssue[], suppressed: PatchLintIssue[], lineCount: number, lintIgnore?: Iterable<string>): void;
+export declare function setCachedPerPatchLintIssues(input: SetCachedPerPatchLintIssuesInput): void;