@hominis/fireforge 0.35.0 → 0.36.0

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

@@ -14,7 +14,7 @@ import { exec } from '../utils/process.js';
 import { applyPatchIdempotent, reversePatch } from './git.js';
 import { getFileContentFromHead } from './git-file-ops.js';
 import { discoverPatches } from './patch-files.js';
-import { findPatchesAffectingFile } from './patch-manifest.js';
+import { findPatchesAffectingFile, loadPatchesManifest } from './patch-manifest.js';
 import { extractAffectedFiles, extractConflictingFiles, isNewFileInPatch } from './patch-parse.js';
 import { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
 // Re-export from split modules so existing import sites continue working
@@ -27,16 +27,23 @@ export { applyPatchToContent, extractNewFileContent } from './patch-transform.js
  * Applies a single patch.
  * @param patch - Patch info
  * @param engineDir - Path to the engine directory
+ * @param protectedFiles - Files touched by patches already applied in the
+ *   current run; the idempotent-recovery reset must not wipe them (see
+ *   applyPatchIdempotent). Overlapping queues (`--allow-overlap`) share
+ *   files between patches, and a later patch's recovery used to reset the
+ *   shared file to HEAD — silently discarding the earlier patch's changes.
  * @returns Patch result
  */
-async function applySinglePatch(patch, engineDir) {
+async function applySinglePatch(patch, engineDir, protectedFiles) {
     let patchContent = '';
     let affectedFiles = [];
     try {
         patchContent = await readText(patch.path);
         affectedFiles = extractAffectedFiles(patchContent);
         await validatePatchTargets(patch, affectedFiles, engineDir);
-        await applyPatchIdempotent(patch.path, engineDir);
+        await applyPatchIdempotent(patch.path, engineDir, {
+            ...(protectedFiles ? { protectedFiles } : {}),
+        });
         return { patch, success: true };
     }
     catch (error) {
@@ -48,21 +55,39 @@ async function applySinglePatch(patch, engineDir) {
         let resolvedNewFiles = false;
         // Save original content for files we might overwrite, so we can restore on failure
         const savedContents = new Map();
-        for (const file of affectedFiles) {
-            if (isNewFileInPatch(patchContent, file)) {
-                const targetPath = join(engineDir, file);
-                if (await pathExists(targetPath)) {
-                    savedContents.set(file, await readText(targetPath));
-                    const content = await extractNewFileContent(patch.path, file);
-                    await writeText(targetPath, content);
-                    resolvedNewFiles = true;
+        try {
+            for (const file of affectedFiles) {
+                if (isNewFileInPatch(patchContent, file)) {
+                    const targetPath = join(engineDir, file);
+                    if (await pathExists(targetPath)) {
+                        savedContents.set(file, await readText(targetPath));
+                        const content = await extractNewFileContent(patch.path, file);
+                        await writeText(targetPath, content);
+                        resolvedNewFiles = true;
+                    }
                 }
             }
         }
+        catch (extractError) {
+            // extractNewFileContent threw for a LATER target (e.g. a binary
+            // section) after earlier targets were already overwritten — restore
+            // them before reporting failure, instead of letting the exception
+            // skip the restore loop entirely and crash the whole import.
+            for (const [file, originalContent] of savedContents) {
+                await writeText(join(engineDir, file), originalContent);
+            }
+            return { patch, success: false, error: toError(extractError).message };
+        }
         if (resolvedNewFiles) {
             try {
-                await applyPatchIdempotent(patch.path, engineDir);
-                return { patch, success: true, autoResolved: true };
+                await applyPatchIdempotent(patch.path, engineDir, {
+                    ...(protectedFiles ? { protectedFiles } : {}),
+                });
+                // Keep the originals: rollbackPatches needs them if a LATER patch
+                // fails, since reverse-applying this new-file patch deletes the
+                // target and would otherwise permanently discard the pre-existing
+                // content (recoverable from git only if it was tracked at HEAD).
+                return { patch, success: true, autoResolved: true, autoResolvedOriginals: savedContents };
             }
             catch (retryError) {
                 verbose(`Auto-resolved new-file retry failed for ${patch.filename}: ${toError(retryError).message}`);
@@ -76,7 +101,10 @@ async function applySinglePatch(patch, engineDir) {
         let errorMessage = applyError.message;
         try {
             // Use --reject to apply what we can and create .rej files for what we can't
-            await applyPatchIdempotent(patch.path, engineDir, { reject: true });
+            await applyPatchIdempotent(patch.path, engineDir, {
+                reject: true,
+                ...(protectedFiles ? { protectedFiles } : {}),
+            });
             // If this somehow succeeds with --reject but failed without, it still shouldn't
             // happen because applyPatch first runs --check which would fail.
             // But if it did succeed, we should still return failure because manual fix is needed
@@ -105,6 +133,19 @@ async function rollbackPatches(results, engineDir) {
         catch (rollbackError) {
             verbose(`Failed to roll back ${result.patch.filename}: ${toError(rollbackError).message}`);
         }
+        // Reversing an auto-resolved new-file patch deletes the target; put
+        // back the pre-existing content the auto-resolve overwrote.
+        if (result.autoResolvedOriginals) {
+            for (const [file, originalContent] of result.autoResolvedOriginals) {
+                try {
+                    await writeText(join(engineDir, file), originalContent);
+                    verbose(`Restored pre-existing content of ${file} after rollback`);
+                }
+                catch (restoreError) {
+                    verbose(`Could not restore ${file}: ${toError(restoreError).message}`);
+                }
+            }
+        }
     }
 }
 /**
@@ -117,9 +158,15 @@ async function rollbackPatches(results, engineDir) {
 export async function applyPatches(patchesDir, engineDir) {
     const patches = await discoverPatches(patchesDir);
     const results = [];
+    const appliedFiles = new Set();
     for (const patch of patches) {
-        const result = await applySinglePatch(patch, engineDir);
+        const result = await applySinglePatch(patch, engineDir, appliedFiles);
         results.push(result);
+        if (result.success) {
+            for (const file of extractAffectedFiles(await readText(patch.path))) {
+                appliedFiles.add(file);
+            }
+        }
         // Stop on first failure and roll back all previously applied patches
         if (!result.success) {
             const succeeded = results.filter((r) => r.success);
@@ -237,7 +284,7 @@ async function resolvePatchWriteDestination(targetPath) {
  * short-circuit was kept behind the numeric gate so the match stays
  * single-meaning per identifier.
  */
-function matchesUntilFilename(patchFilename, needle) {
+export function matchesUntilFilename(patchFilename, needle) {
     const isNumeric = /^\d+$/.test(needle);
     if (isNumeric) {
         const order = parseInt(needle, 10);
@@ -298,6 +345,7 @@ export async function applyPatchesWithContinue(patchesDir, engineDir, optionsOrC
     const succeeded = [];
     const failed = [];
     const skipped = [];
+    const appliedFiles = new Set();
     for (let i = 0; i < patches.length; i++) {
         const patch = patches[i];
         if (!patch)
@@ -309,9 +357,12 @@ export async function applyPatchesWithContinue(patchesDir, engineDir, optionsOrC
             skipped.push(patch);
             continue;
         }
-        const result = await applySinglePatch(patch, engineDir);
+        const result = await applySinglePatch(patch, engineDir, appliedFiles);
         if (result.success) {
             succeeded.push(result);
+            for (const file of extractAffectedFiles(await readText(patch.path))) {
+                appliedFiles.add(file);
+            }
         }
         else {
             // Try to extract conflicting files from error message
@@ -362,4 +413,36 @@ export async function computePatchedContent(patchesDir, engineDir, filePath) {
     }
     return content;
 }
-//# sourceMappingURL=patch-apply.js.map
+/**
+ * Builds a batched variant of {@link computePatchedContent} that loads the
+ * manifest and discovers patch files ONCE for many lookups. The per-call
+ * function re-runs `loadPatchesManifest` + `discoverPatches` for every
+ * file — O(dirtyFiles × patches) redundant IO when classifying a broad
+ * engine edit session during `import`.
+ */
+export async function createPatchedContentComputer(patchesDir, engineDir) {
+    const manifest = await loadPatchesManifest(patchesDir);
+    const patches = await discoverPatches(patchesDir);
+    const patchByFilename = new Map(patches.map((p) => [p.filename, p]));
+    const affectingByFile = new Map();
+    for (const metadata of manifest?.patches ?? []) {
+        const patch = patchByFilename.get(metadata.filename);
+        if (!patch)
+            continue;
+        for (const file of metadata.filesAffected) {
+            const list = affectingByFile.get(file) ?? [];
+            list.push(patch);
+            affectingByFile.set(file, list);
+        }
+    }
+    for (const list of affectingByFile.values()) {
+        list.sort((a, b) => a.order - b.order);
+    }
+    return async (filePath) => {
+        let content = await getFileContentFromHead(engineDir, filePath);
+        for (const patch of affectingByFile.get(filePath) ?? []) {
+            content = await applyPatchToContent(content, patch.path, filePath);
+        }
+        return content;
+    };
+}

package/dist/src/core/patch-artifact-normalize.d.ts

@@ -1,10 +1,23 @@
 /**
  * Normalizes generated patch files before they are written to disk.
  *
- * Kept as a narrow chokepoint for future artifact-level fixes. It must keep
- * unified-diff hunk markers intact, but marker-only blank payload lines should
- * not carry extra trailing whitespace (`"+ "` / `"- "` / `"  "`), because raw
- * repository whitespace checks flag those generated patch artifact lines even
- * when the engine diff is clean.
+ * Currently the identity function, kept as a narrow chokepoint for future
+ * artifact-level fixes so every export path (`commitExportedPatch`,
+ * `commitPlacementExport`, `updatePatch`, `patch split`) funnels through
+ * one place.
+ *
+ * History: this used to strip marker lines whose payload was pure
+ * whitespace (`/^[ +-]\s+$/` → bare marker) to appease repository
+ * trailing-whitespace checks. That corrupted real content — Firefox
+ * sources contain whitespace-only lines, so a ` `/`-` line whose payload
+ * was e.g. two spaces no longer matched the pristine tree (the freshly
+ * exported patch failed `git apply --check`), and a `+` line silently
+ * changed what the patch produces, making re-import diverge from the
+ * engine state it was exported from (2026-07-05 review, finding M2).
+ * The whitespace check itself excludes `patches/*.patch`
+ * (scripts/check-worktree-whitespace.mjs), so the trimming had no
+ * remaining justification. Patch bodies are now written byte-for-byte as
+ * git produced them — including the single-space rendering of blank
+ * context lines, which `re-export.integration.test.ts` pins.
  */
 export declare function normalizePatchArtifact(content: string): string;

package/dist/src/core/patch-artifact-normalize.js

@@ -2,21 +2,25 @@
 /**
  * Normalizes generated patch files before they are written to disk.
  *
- * Kept as a narrow chokepoint for future artifact-level fixes. It must keep
- * unified-diff hunk markers intact, but marker-only blank payload lines should
- * not carry extra trailing whitespace (`"+ "` / `"- "` / `"  "`), because raw
- * repository whitespace checks flag those generated patch artifact lines even
- * when the engine diff is clean.
+ * Currently the identity function, kept as a narrow chokepoint for future
+ * artifact-level fixes so every export path (`commitExportedPatch`,
+ * `commitPlacementExport`, `updatePatch`, `patch split`) funnels through
+ * one place.
+ *
+ * History: this used to strip marker lines whose payload was pure
+ * whitespace (`/^[ +-]\s+$/` → bare marker) to appease repository
+ * trailing-whitespace checks. That corrupted real content — Firefox
+ * sources contain whitespace-only lines, so a ` `/`-` line whose payload
+ * was e.g. two spaces no longer matched the pristine tree (the freshly
+ * exported patch failed `git apply --check`), and a `+` line silently
+ * changed what the patch produces, making re-import diverge from the
+ * engine state it was exported from (2026-07-05 review, finding M2).
+ * The whitespace check itself excludes `patches/*.patch`
+ * (scripts/check-worktree-whitespace.mjs), so the trimming had no
+ * remaining justification. Patch bodies are now written byte-for-byte as
+ * git produced them — including the single-space rendering of blank
+ * context lines, which `re-export.integration.test.ts` pins.
  */
 export function normalizePatchArtifact(content) {
-    return content
-        .split('\n')
-        .map((line) => {
-        if (/^[ +-]\s+$/.test(line)) {
-            return line[0] ?? line;
-        }
-        return line;
-    })
-        .join('\n');
+    return content;
 }
-//# sourceMappingURL=patch-artifact-normalize.js.map

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

@@ -100,4 +100,3 @@ export async function findAllPatchesForFilesWithDetails(patchesDir, targetFiles,
     }
     return results;
 }
-//# sourceMappingURL=patch-export-coverage.js.map

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

@@ -36,4 +36,3 @@ export async function mutatePatchMetadata(patchesDir, filename, mutator) {
         return { before: changed.before, after: changed.after };
     });
 }
-//# sourceMappingURL=patch-export-metadata.js.map

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

@@ -5,7 +5,7 @@ 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 { loadPatchesManifest, mutatePatchRowsInManifest } from './patch-manifest.js';
+import { loadPatchesManifestForWrite, mutatePatchRowsInManifest } from './patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
 /**
  * Updates a patch file body and its manifest row under the same patch
@@ -14,7 +14,7 @@ import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
  */
 export async function updatePatchAndMetadata(patchesDir, filename, newContent, updates, onCommitted, policyGate) {
     await withPatchDirectoryLock(patchesDir, async () => {
-        const manifest = await loadPatchesManifest(patchesDir);
+        const manifest = await loadPatchesManifestForWrite(patchesDir);
         if (!manifest) {
             throw new Error('Cannot update patch metadata: patches.json is missing.');
         }
@@ -65,4 +65,3 @@ export async function updatePatchAndMetadata(patchesDir, filename, newContent, u
         }
     });
 }
-//# sourceMappingURL=patch-export-update.js.map

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

@@ -30,6 +30,8 @@ export declare function sanitizeName(name: string): string;
  * double-prefix incident) also collapses. Exported for direct testing.
  */
 export declare function stripRedundantCategoryPrefix(sanitizedName: string, category: string): string;
+/** Sanitizes a patch name and drops redundant category/full-stem prefixes. */
+export declare function patchNameSlug(name: string, category: string): string;
 /**
  * Generates the next patch filename with category.
  * @param patchesDir - Path to the patches directory
@@ -99,12 +101,6 @@ export declare function findExistingPatchForFile(patchesDir: string, filePath: s
  * @param newContent - New patch content
  */
 export declare function updatePatch(patchPath: string, newContent: string): Promise<void>;
-/**
- * Deletes a patch file and removes it from the manifest.
- * @param patchesDir - Path to the patches directory
- * @param filename - Patch filename to delete
- */
-export declare function deletePatch(patchesDir: string, filename: string): Promise<void>;
 /**
  * Fully computed plan for a pending export. Returned from
  * {@link planExport} so that `--dry-run` previews can render the full

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

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
@@ -8,7 +7,7 @@ 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, loadPatchesManifest, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
+import { addPatchToManifest, loadPatchesManifestForWrite, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
 import { allocatePolicyOrder, enforcePatchPolicy } from './patch-policy.js';
 export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, findSupersededPatches, isPatchFullyCovered, } from './patch-export-coverage.js';
 export { mutatePatchMetadata, updatePatchMetadata, } from './patch-export-metadata.js';
@@ -46,6 +45,9 @@ export function sanitizeName(name) {
         .replace(/^-+|-+$/g, '')
         .slice(0, 50);
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 /**
  * Strips a leading `NNN-<category>-` prefix from a sanitized name slug.
  * Operators frequently pass the DESIRED FILENAME stem to `--name`
@@ -56,15 +58,25 @@ export function sanitizeName(name) {
  * double-prefix incident) also collapses. Exported for direct testing.
  */
 export function stripRedundantCategoryPrefix(sanitizedName, category) {
-    const prefix = new RegExp(`^\\d+-${category}-`);
+    const prefixes = [
+        new RegExp(`^\\d+-${escapeRegExp(category)}-`),
+        new RegExp(`^${escapeRegExp(category)}-`),
+    ];
     let stripped = sanitizedName;
-    while (prefix.test(stripped)) {
-        stripped = stripped.replace(prefix, '');
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const prefix of prefixes) {
+            if (prefix.test(stripped)) {
+                stripped = stripped.replace(prefix, '');
+                changed = true;
+            }
+        }
     }
     return stripped.length > 0 ? stripped : sanitizedName;
 }
-/** Sanitizes a patch name and drops a redundant `NNN-<category>-` prefix. */
-function patchNameSlug(name, category) {
+/** Sanitizes a patch name and drops redundant category/full-stem prefixes. */
+export function patchNameSlug(name, category) {
     return stripRedundantCategoryPrefix(sanitizeName(name), category);
 }
 /**
@@ -221,45 +233,6 @@ export async function findExistingPatchForFile(patchesDir, filePath) {
 export async function updatePatch(patchPath, newContent) {
     await writeText(patchPath, normalizePatchArtifact(newContent));
 }
-/**
- * Deletes a patch file and removes it from the manifest.
- * @param patchesDir - Path to the patches directory
- * @param filename - Patch filename to delete
- */
-export async function deletePatch(patchesDir, filename) {
-    await withPatchDirectoryLock(patchesDir, async () => {
-        const patchPath = join(patchesDir, filename);
-        const manifest = await loadPatchesManifest(patchesDir);
-        const updatedManifest = manifest
-            ? {
-                ...manifest,
-                patches: manifest.patches.filter((patch) => patch.filename !== filename),
-            }
-            : null;
-        // Update manifest first so interrupted deletions leave an explicit repairable
-        // extra patch file rather than silently dropping metadata for an absent file.
-        if (updatedManifest) {
-            await savePatchesManifest(patchesDir, updatedManifest);
-        }
-        if (!(await pathExists(patchPath))) {
-            return;
-        }
-        try {
-            await unlink(patchPath);
-        }
-        catch (error) {
-            if (manifest) {
-                try {
-                    await savePatchesManifest(patchesDir, manifest);
-                }
-                catch (error) {
-                    warn(`Failed to restore manifest after patch deletion error for "${filename}": ${toError(error).message}`);
-                }
-            }
-            throw error;
-        }
-    });
-}
 /**
  * Internal planning helper. Does NOT take the patch directory lock — the
  * caller must already hold it — because the two public entry points
@@ -269,7 +242,11 @@ export async function deletePatch(patchesDir, filename) {
  * instead of by parallel implementations that can drift.
  */
 async function computeExportPlanUnderLock(input) {
-    const manifestBefore = await loadPatchesManifest(input.patchesDir);
+    // ForWrite: a corrupt manifest read as null here would produce a
+    // manifestAfter containing ONLY the new patch — committing that plan
+    // wipes the queue metadata, and the rollback path would then delete
+    // patches.json entirely because manifestBefore looked absent.
+    const manifestBefore = await loadPatchesManifestForWrite(input.patchesDir);
     const policyOrder = input.config !== undefined
         ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category)
         : null;
@@ -341,4 +318,3 @@ export async function planExport(input) {
         };
     });
 }
-//# sourceMappingURL=patch-export.js.map

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

@@ -51,4 +51,3 @@ export async function getAllTargetFilesFromPatch(patchPath) {
     const content = await readText(patchPath);
     return extractAffectedFiles(content);
 }
-//# sourceMappingURL=patch-files.js.map

package/dist/src/core/patch-identifier-suggest.js

@@ -105,4 +105,3 @@ export function formatPatchNotFoundError(identifier, patches) {
     }
     return `${lead} No close match found among ${patches.length} patches in the queue. Run "fireforge patch list" to see them.`;
 }
-//# sourceMappingURL=patch-identifier-suggest.js.map

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

@@ -414,4 +414,3 @@ export async function invokePatchLintCheckJsGrouped(repoDir, patchOwnedFiles, pa
         : { strict };
     return runCheckJsGrouped(repoDir, patchOwnedFiles, patchLint.checkJsExtraShim, projectRoot, mode);
 }
-//# sourceMappingURL=patch-lint-checkjs.js.map

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

@@ -84,4 +84,3 @@ export function lintChromeScriptJsDocForFile(file, content, isChromeOwned, mode)
         severity: issue.severity ?? mode,
     }));
 }
-//# sourceMappingURL=patch-lint-chrome-jsdoc.js.map

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

@@ -495,4 +495,3 @@ export function lintPatchQueueForwardImports(ctx) {
 export function lintPatchQueue(ctx) {
     return [...lintPatchQueueDuplicateCreations(ctx), ...lintPatchQueueForwardImports(ctx)];
 }
-//# sourceMappingURL=patch-lint-cross.js.map

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

@@ -169,4 +169,3 @@ export async function lintPatchedCss(repoDir, affectedFiles, diffContent, config
     }
     return issues;
 }
-//# sourceMappingURL=patch-lint-css.js.map

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

@@ -105,4 +105,3 @@ export function tagLintIssues(issues, diffFiles) {
     }
     return issues;
 }
-//# sourceMappingURL=patch-lint-diff-tag.js.map

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

@@ -6,7 +6,8 @@
  * cross-patch lint body (in `patch-lint-cross.ts`) can both depend on
  * the same diff walkers without inducing a circular import. Callers
  * should keep importing these through `patch-lint.ts` — this file is
- * an implementation detail.
+ * an implementation detail. The actual line-walking lives in
+ * `parseDiffSections` (patch-parse.ts), the codebase's single diff walker.
  */
 /**
  * Extracts new-file paths from a unified diff by scanning for `new file mode` markers.

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

@@ -7,23 +7,18 @@
  * cross-patch lint body (in `patch-lint-cross.ts`) can both depend on
  * the same diff walkers without inducing a circular import. Callers
  * should keep importing these through `patch-lint.ts` — this file is
- * an implementation detail.
+ * an implementation detail. The actual line-walking lives in
+ * `parseDiffSections` (patch-parse.ts), the codebase's single diff walker.
  */
+import { parseDiffSections } from './patch-parse.js';
 /**
  * Extracts new-file paths from a unified diff by scanning for `new file mode` markers.
  */
 export function detectNewFilesInDiff(diffContent) {
     const newFiles = new Set();
-    const lines = diffContent.split('\n');
-    let currentFile = null;
-    for (const line of lines) {
-        if (line.startsWith('diff --git')) {
-            const match = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-            currentFile = match?.[1] ?? null;
-            continue;
-        }
-        if (line.startsWith('new file mode') && currentFile) {
-            newFiles.add(currentFile);
+    for (const section of parseDiffSections(diffContent)) {
+        if (section.isNewFile) {
+            newFiles.add(section.targetPath);
         }
     }
     return newFiles;
@@ -34,27 +29,18 @@ export function detectNewFilesInDiff(diffContent) {
  */
 export function extractAddedLinesPerFile(diffContent) {
     const result = new Map();
-    const lines = diffContent.split('\n');
-    let currentFile = null;
-    let inHunk = false;
-    for (const line of lines) {
-        if (line.startsWith('diff --git')) {
-            const match = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-            currentFile = match?.[1] ?? null;
-            inHunk = false;
-            continue;
-        }
-        if (line.startsWith('@@')) {
-            inHunk = true;
-            continue;
-        }
-        if (inHunk && currentFile && line.startsWith('+') && !line.startsWith('+++')) {
-            let arr = result.get(currentFile);
-            if (!arr) {
-                arr = [];
-                result.set(currentFile, arr);
+    for (const section of parseDiffSections(diffContent)) {
+        for (const hunk of section.hunks) {
+            for (const line of hunk.lines) {
+                if (!line.startsWith('+'))
+                    continue;
+                let arr = result.get(section.targetPath);
+                if (!arr) {
+                    arr = [];
+                    result.set(section.targetPath, arr);
+                }
+                arr.push(line.slice(1));
             }
-            arr.push(line.slice(1));
         }
     }
     return result;
@@ -81,4 +67,3 @@ export function buildModifiedFileAdditionsFromDiff(diff) {
     }
     return result;
 }
-//# sourceMappingURL=patch-lint-diff.js.map

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

@@ -65,4 +65,3 @@ export function hasRelativeImport(content) {
     }
     return RELATIVE_IMPORT_FALLBACK_PATTERN.test(stripJsComments(content));
 }
-//# sourceMappingURL=patch-lint-imports.js.map

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

@@ -450,4 +450,3 @@ export function validateExportJsDoc(source, options) {
     }
     return issues;
 }
-//# sourceMappingURL=patch-lint-jsdoc.js.map

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

@@ -165,4 +165,3 @@ export function lintObserverTopics(strippedContent, file, binaryName) {
     }
     return issues;
 }
-//# sourceMappingURL=patch-lint-observer.js.map

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

@@ -67,4 +67,3 @@ export function resolvePatchOwnedSysMjs(currentNewFiles, patchQueueCtx) {
 export function resolvePatchOwnedChromeScripts(currentNewFiles, patchQueueCtx) {
     return resolveOwned(currentNewFiles, patchQueueCtx, (file) => file.endsWith('.js') && !file.endsWith('.sys.mjs'));
 }
-//# sourceMappingURL=patch-lint-ownership.js.map

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

@@ -5,4 +5,3 @@
  */
 export { buildPatchQueueContext, collectForwardImportEdges, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
-//# sourceMappingURL=patch-lint-reexports.js.map