@hominis/fireforge 0.34.2 → 0.36.0

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

@@ -12,8 +12,9 @@ import { rename } from 'node:fs/promises';
 import { join } from 'node:path';
 import { FireForgeError } from '../errors/base.js';
 import { ExitCode } from '../errors/codes.js';
+import { PatchManifestCorruptError } from '../errors/patch.js';
 import { toError } from '../utils/errors.js';
-import { pathExists, readJson, removeFile, writeJson } from '../utils/fs.js';
+import { pathExistsStrict, readJson, removeFile, writeJson } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { isArray, isObject } from '../utils/validation.js';
 import { validatePatchesManifest } from './patch-manifest-validate.js';
@@ -25,7 +26,7 @@ export const PATCHES_MANIFEST = 'patches.json';
  */
 export async function loadPatchesManifestState(patchesDir) {
     const manifestPath = join(patchesDir, PATCHES_MANIFEST);
-    if (!(await pathExists(manifestPath))) {
+    if (!(await pathExistsStrict(manifestPath))) {
         return { exists: false, manifest: null, parseError: undefined };
     }
     try {
@@ -46,6 +47,13 @@ export async function loadPatchesManifestState(patchesDir) {
 }
 /**
  * Loads the patches manifest if it exists.
+ *
+ * READ-ONLY callers only: this collapses "absent" and "corrupt" into null.
+ * Any code path that will WRITE the manifest (or delete patch files based
+ * on its content) must use {@link loadPatchesManifestForWrite} instead —
+ * treating a corrupt manifest as empty and then saving destroys every
+ * existing patch's metadata.
+ *
  * @param patchesDir - Path to the patches directory
  * @returns PatchesManifest or null if not found
  */
@@ -53,6 +61,21 @@ export async function loadPatchesManifest(patchesDir) {
     const state = await loadPatchesManifestState(patchesDir);
     return state.manifest;
 }
+/**
+ * Loads the patches manifest for a mutating operation.
+ *
+ * Returns null only when the manifest genuinely does not exist; a manifest
+ * that exists but fails to parse/validate throws
+ * {@link PatchManifestCorruptError} so the caller aborts instead of
+ * rebuilding an empty queue over the top of the corrupt file.
+ */
+export async function loadPatchesManifestForWrite(patchesDir) {
+    const state = await loadPatchesManifestState(patchesDir);
+    if (state.exists && state.manifest === null) {
+        throw new PatchManifestCorruptError(join(patchesDir, PATCHES_MANIFEST), state.parseError);
+    }
+    return state.manifest;
+}
 /**
  * Saves the patches manifest.
  * @param patchesDir - Path to the patches directory
@@ -70,7 +93,7 @@ export async function savePatchesManifest(patchesDir, manifest) {
  */
 export async function mutatePatchRowsInManifest(patchesDir, filenames, mutator) {
     const manifestPath = join(patchesDir, PATCHES_MANIFEST);
-    if (!(await pathExists(manifestPath)))
+    if (!(await pathExistsStrict(manifestPath)))
         return null;
     const rawManifest = await readJson(manifestPath);
     const beforeManifest = validatePatchesManifest(rawManifest);
@@ -125,7 +148,8 @@ export async function mutatePatchRowsInManifest(patchesDir, filenames, mutator)
  * @param removeFilenames - Optional filenames to remove in the same read-modify-write cycle
  */
 export async function addPatchToManifest(patchesDir, metadata, removeFilenames) {
-    const manifest = (await loadPatchesManifest(patchesDir)) ?? {
+    // ForWrite: a corrupt manifest must abort here, not be rebuilt as empty.
+    const manifest = (await loadPatchesManifestForWrite(patchesDir)) ?? {
         version: 1,
         patches: [],
     };
@@ -156,7 +180,7 @@ export async function addPatchToManifest(patchesDir, metadata, removeFilenames)
  *   false when no matching entry existed
  */
 export async function removePatchFromManifest(patchesDir, filename) {
-    const manifest = await loadPatchesManifest(patchesDir);
+    const manifest = await loadPatchesManifestForWrite(patchesDir);
     if (!manifest)
         return false;
     const originalLength = manifest.patches.length;
@@ -240,7 +264,7 @@ export function rewriteStagedDependencyOwners(patch, renameLookup) {
 export async function renumberPatchesInManifest(patchesDir, renameMap) {
     if (renameMap.size === 0)
         return;
-    const manifest = await loadPatchesManifest(patchesDir);
+    const manifest = await loadPatchesManifestForWrite(patchesDir);
     if (!manifest) {
         throw new Error('Cannot renumber patches: patches.json is missing.');
     }
@@ -252,7 +276,7 @@ export async function renumberPatchesInManifest(patchesDir, renameMap) {
     try {
         for (const [oldFilename, entry] of renameMap) {
             const oldPath = join(patchesDir, oldFilename);
-            if (!(await pathExists(oldPath))) {
+            if (!(await pathExistsStrict(oldPath))) {
                 throw new Error(`Cannot renumber: patch file is missing on disk: ${oldFilename}`);
             }
             const stagedName = `.fireforge-renumber-${stagingId}-${oldFilename}`;
@@ -280,7 +304,7 @@ export async function renumberPatchesInManifest(patchesDir, renameMap) {
         for (const stagedEntry of stagedRenames) {
             const { staged, toEntry } = stagedEntry;
             const targetPath = join(patchesDir, toEntry.newFilename);
-            if (await pathExists(targetPath)) {
+            if (await pathExistsStrict(targetPath)) {
                 throw new Error(`Cannot renumber: target patch filename already exists on disk: ${toEntry.newFilename}`);
             }
             await rename(join(patchesDir, staged), targetPath);
@@ -291,7 +315,7 @@ export async function renumberPatchesInManifest(patchesDir, renameMap) {
             // described: manifest rewrote to new filenames while the old
             // files stayed on disk. If the assert ever fires, the Phase 2
             // rollback will undo prior moves before re-throwing.
-            if (!(await pathExists(targetPath))) {
+            if (!(await pathExistsStrict(targetPath))) {
                 throw new Error(`Rename postcondition failed: expected ${toEntry.newFilename} to exist after rename, but it was not found on disk.`);
             }
             completedFinalRenames.push(stagedEntry);
@@ -425,10 +449,12 @@ export class PatchDeleteRollbackError extends FireForgeError {
  */
 export async function removePatchFileAndManifest(patchesDir, filename) {
     const patchPath = join(patchesDir, filename);
-    const originalManifest = await loadPatchesManifest(patchesDir);
+    // ForWrite: deleting the patch FILE while a corrupt manifest still
+    // references it would strand the queue; abort on corruption instead.
+    const originalManifest = await loadPatchesManifestForWrite(patchesDir);
     const removedFromManifest = await removePatchFromManifest(patchesDir, filename);
     try {
-        if (await pathExists(patchPath)) {
+        if (await pathExistsStrict(patchPath)) {
             await removeFile(patchPath);
         }
     }
@@ -451,4 +477,3 @@ export async function removePatchFileAndManifest(patchesDir, filename) {
         throw deleteError;
     }
 }
-//# sourceMappingURL=patch-manifest-io.js.map

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

@@ -42,6 +42,12 @@ export declare function validatePatchIntegrity(patchesDir: string, engineDir: st
 /**
  * Stamps multiple patches with a new source version in a single
  * manifest read-modify-write cycle.
+ *
+ * Acquires the shared patch-directory lock for the read-modify-write, so a
+ * concurrent export/reorder/metadata update cannot interleave with the stamp.
+ * The lock is not reentrant — callers must NOT invoke this while already
+ * holding {@link withPatchDirectoryLock} on the same patches directory.
+ *
  * @param patchesDir - Path to the patches directory
  * @param filenames - Patch filenames to update
  * @param newVersion - Version string to set (e.g. "140.9.0esr")

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

@@ -3,8 +3,9 @@
  * Query helpers: finding patches by file, integrity checks, version compat, stamping.
  */
 import { readText } from '../utils/fs.js';
-import { fileExistsInHead } from './git-file-ops.js';
+import { listTrackedInHead } from './git-file-ops.js';
 import { discoverPatches, getAllTargetFilesFromPatch } from './patch-files.js';
+import { withPatchDirectoryLock } from './patch-lock.js';
 import { loadPatchesManifest, mutatePatchRowsInManifest } from './patch-manifest-io.js';
 import { isNewFileInPatch } from './patch-parse.js';
 /**
@@ -78,6 +79,12 @@ export async function findPatchesAffectingFile(patchesDir, filePath) {
 export async function validatePatchIntegrity(patchesDir, engineDir) {
     const issues = [];
     const patches = await discoverPatches(patchesDir);
+    // Collect every modification target first, then resolve HEAD existence in
+    // ONE batched ls-tree pass (chunked for ARG_MAX). The per-file
+    // fileExistsInHead fan-out spawned one git process per (patch × target) on
+    // every import — a 56-file branding patch alone cost ~56 spawns before a
+    // single patch was applied.
+    const modificationTargets = [];
     for (const patch of patches) {
         // Check all files in the patch (supports multi-file patches)
         const patchContent = await readText(patch.path);
@@ -86,14 +93,17 @@ export async function validatePatchIntegrity(patchesDir, engineDir) {
             // Skip new-file sections — they don't need to exist in HEAD
             if (isNewFileInPatch(patchContent, targetFile))
                 continue;
-            const existsInHead = await fileExistsInHead(engineDir, targetFile);
-            if (!existsInHead) {
-                issues.push({
-                    filename: patch.filename,
-                    message: `Modification patch for file that doesn't exist in source. Re-export with: fireforge export ${targetFile}`,
-                    targetFile,
-                });
-            }
+            modificationTargets.push({ filename: patch.filename, targetFile });
+        }
+    }
+    const tracked = await listTrackedInHead(engineDir, modificationTargets.map((t) => t.targetFile));
+    for (const { filename, targetFile } of modificationTargets) {
+        if (!tracked.has(targetFile)) {
+            issues.push({
+                filename,
+                message: `Modification patch for file that doesn't exist in source. Re-export with: fireforge export ${targetFile}`,
+                targetFile,
+            });
         }
     }
     return issues;
@@ -101,12 +111,18 @@ export async function validatePatchIntegrity(patchesDir, engineDir) {
 /**
  * Stamps multiple patches with a new source version in a single
  * manifest read-modify-write cycle.
+ *
+ * Acquires the shared patch-directory lock for the read-modify-write, so a
+ * concurrent export/reorder/metadata update cannot interleave with the stamp.
+ * The lock is not reentrant — callers must NOT invoke this while already
+ * holding {@link withPatchDirectoryLock} on the same patches directory.
+ *
  * @param patchesDir - Path to the patches directory
  * @param filenames - Patch filenames to update
  * @param newVersion - Version string to set (e.g. "140.9.0esr")
  */
 export async function stampPatchVersions(patchesDir, filenames, newVersion, newProduct) {
-    await mutatePatchRowsInManifest(patchesDir, filenames, (patch, rawPatch) => {
+    await withPatchDirectoryLock(patchesDir, () => mutatePatchRowsInManifest(patchesDir, filenames, (patch, rawPatch) => {
         if (patch.sourceEsrVersion !== newVersion ||
             rawPatch['sourceVersion'] !== newVersion ||
             (newProduct !== undefined && rawPatch['sourceProduct'] !== newProduct)) {
@@ -119,6 +135,5 @@ export async function stampPatchVersions(patchesDir, filenames, newVersion, newP
             };
         }
         return null;
-    });
+    }));
 }
-//# sourceMappingURL=patch-manifest-query.js.map

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

@@ -36,4 +36,3 @@ export function resolvePatchIdentifier(identifier, patches) {
     // manifest at export time. See function docstring.
     return patches.find((p) => p.name === identifier) ?? null;
 }
-//# sourceMappingURL=patch-manifest-resolve.js.map

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

@@ -144,4 +144,3 @@ export function inferPatchMetadataFromFilename(filename) {
     }
     return { category: 'infra', name: filename.replace(/\.patch$/, '') };
 }
-//# sourceMappingURL=patch-manifest-validate.js.map

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

@@ -5,7 +5,7 @@
  * is an implementation detail.
  */
 export { rebuildPatchesManifest, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { addPatchToManifest, loadPatchesManifest, mutatePatchRowsInManifest, PATCHES_MANIFEST, type PatchManifestRowMutation, type PatchManifestRowMutationResult, type PatchRenameEntry, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
+export { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, mutatePatchRowsInManifest, PATCHES_MANIFEST, type PatchManifestRowMutation, type PatchManifestRowMutationResult, type PatchRenameEntry, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
 export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
 export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
 export { validatePatchesManifest } from './patch-manifest-validate.js';

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

@@ -6,8 +6,7 @@
  * is an implementation detail.
  */
 export { rebuildPatchesManifest, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { addPatchToManifest, loadPatchesManifest, mutatePatchRowsInManifest, PATCHES_MANIFEST, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
+export { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, mutatePatchRowsInManifest, PATCHES_MANIFEST, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
 export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
 export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
 export { validatePatchesManifest } from './patch-manifest-validate.js';
-//# sourceMappingURL=patch-manifest.js.map

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

@@ -1,6 +1,15 @@
 /**
  * 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. Before
+ * {@link parseDiffSections} existed, six hand-rolled `diff --git` walkers
+ * lived across patch-parse, patch-lint-diff, patch-registration-refs, and
+ * patch-transform — with divergent CRLF handling (a CRLF-saved patch file
+ * silently failed target-file matching and `\ No newline` detection on
+ * Windows), no 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.
  */
 /**
  * Extracts the order number from a patch filename.
@@ -9,6 +18,56 @@
  * @returns Order number, or Infinity if no prefix
  */
 export declare function extractOrder(filename: string): number;
+/**
+ * A parsed `diff --git` header: both sides' paths, unquoted and with any
+ * CRLF residue stripped.
+ */
+export interface DiffGitHeader {
+    /** Old-side (`a/`) path. */
+    sourcePath: string;
+    /** New-side (`b/`) path — the file the patch produces. */
+    targetPath: string;
+}
+/**
+ * Parses a `diff --git` line into its two paths.
+ *
+ * Handles the quoted form git emits for paths with special characters
+ * (`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 — the previous greedy regex
+ * (`a\/.+ b\/(.+)$`) split such lines at the LAST ` b/` and returned a
+ * truncated path. Falls back to a non-greedy split for renames.
+ *
+ * @returns null when the line is not a diff --git header.
+ */
+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. */
+    targetPath: string;
+    /** Old-side (`a/`) path. */
+    sourcePath: string;
+    /** True when the section carries a `new file mode` marker. */
+    isNewFile: boolean;
+    /** True when the section carries a `deleted file mode` marker. */
+    isDeletedFile: boolean;
+    /**
+     * True for binary sections (`GIT binary patch` or `Binary files … differ`).
+     * Binary sections have no parseable hunks; text-oriented consumers must
+     * refuse them rather than treat base85 lines starting with `+` as content.
+     */
+    isBinary: boolean;
+    /** 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.
+ */
+export declare function parseDiffSections(diffContent: string): DiffSection[];
 /**
  * Checks whether a specific file is a new-file addition within a patch.
  * For multi-file patches, only inspects the section belonging to targetFile.