@hominis/fireforge 0.35.0 → 0.37.0

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

@@ -12,6 +12,7 @@ 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 { pathExistsStrict, readJson, removeFile, writeJson } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
@@ -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
@@ -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;
@@ -168,8 +192,9 @@ export async function removePatchFromManifest(patchesDir, filename) {
     return true;
 }
 /**
- * Rewrites `stagedDependencies.forwardImports[].owner` references on one
- * patch through a rename lookup. Owners embed exact patch filenames, so any
+ * Rewrites `stagedDependencies.forwardImports[].owner` and
+ * `stagedDependencies.registrations[].owner` references on one patch
+ * through a rename lookup. Owners embed exact patch filenames, so any
  * renumber (compact, reorder, placement export, rename) that does not remap
  * them leaves dangling references that surface as false forward-import
  * errors on the next lint.
@@ -183,25 +208,35 @@ export async function removePatchFromManifest(patchesDir, filename) {
  * @returns The same row, or a copy with remapped owners
  */
 export function rewriteStagedDependencyOwners(patch, renameLookup) {
-    const forwardImports = patch.stagedDependencies?.forwardImports;
-    if (!forwardImports || forwardImports.length === 0)
+    const staged = patch.stagedDependencies;
+    if (!staged)
         return patch;
-    const rewritten = forwardImports.map((fi) => {
-        if (!fi.owner)
-            return fi;
-        const newOwner = renameLookup(fi.owner);
-        if (newOwner === undefined || newOwner === fi.owner)
-            return fi;
-        return { ...fi, owner: newOwner };
-    });
-    const changed = rewritten.some((fi, index) => fi !== forwardImports[index]);
-    if (!changed)
+    const rewriteOwners = (entries) => {
+        if (!entries || entries.length === 0)
+            return { entries, changed: false };
+        const rewritten = entries.map((entry) => {
+            if (!entry.owner)
+                return entry;
+            const newOwner = renameLookup(entry.owner);
+            if (newOwner === undefined || newOwner === entry.owner)
+                return entry;
+            return { ...entry, owner: newOwner };
+        });
+        return {
+            entries: rewritten,
+            changed: rewritten.some((entry, index) => entry !== entries[index]),
+        };
+    };
+    const forwardImports = rewriteOwners(staged.forwardImports);
+    const registrations = rewriteOwners(staged.registrations);
+    if (!forwardImports.changed && !registrations.changed)
         return patch;
     return {
         ...patch,
         stagedDependencies: {
-            ...patch.stagedDependencies,
-            forwardImports: rewritten,
+            ...staged,
+            ...(forwardImports.entries !== undefined ? { forwardImports: forwardImports.entries } : {}),
+            ...(registrations.entries !== undefined ? { registrations: registrations.entries } : {}),
         },
     };
 }
@@ -240,7 +275,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.');
     }
@@ -425,7 +460,9 @@ 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 pathExistsStrict(patchPath)) {
@@ -451,4 +488,3 @@ export async function removePatchFileAndManifest(patchesDir, filename) {
         throw deleteError;
     }
 }
-//# sourceMappingURL=patch-manifest-io.js.map

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

@@ -3,7 +3,7 @@
  * 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';
@@ -79,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);
@@ -87,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;
@@ -128,4 +137,3 @@ 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

@@ -24,13 +24,37 @@ function parseForwardImports(data, label) {
         return dependency;
     });
 }
+function parseRegistrations(data, label) {
+    if (!isArray(data)) {
+        throw new Error(`${label} must be an array`);
+    }
+    return data.map((entry, index) => {
+        const rec = parseObject(entry, `${label}[${index}]`);
+        const dependency = {
+            file: rec.string('file'),
+            line: rec.string('line'),
+            creates: rec.string('creates'),
+        };
+        const owner = rec.optionalString('owner');
+        if (owner !== undefined)
+            dependency.owner = owner;
+        const reason = rec.optionalString('reason');
+        if (reason !== undefined)
+            dependency.reason = reason;
+        return dependency;
+    });
+}
 function parseStagedDependencies(data, label) {
     const rec = parseObject(data, label);
     const rawForwardImports = rec.raw('forwardImports');
+    const rawRegistrations = rec.raw('registrations');
     const staged = {};
     if (rawForwardImports !== undefined) {
         staged.forwardImports = parseForwardImports(rawForwardImports, `${label}.forwardImports`);
     }
+    if (rawRegistrations !== undefined) {
+        staged.registrations = parseRegistrations(rawRegistrations, `${label}.registrations`);
+    }
     return staged;
 }
 /**
@@ -144,4 +168,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.