@hominis/fireforge 0.35.0 → 0.37.0

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

@@ -2,6 +2,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.
@@ -17,87 +26,155 @@ export function extractOrder(filename) {
     return Infinity;
 }
 /**
- * Checks whether a specific file is a new-file addition within a patch.
- * For multi-file patches, only inspects the section belonging to targetFile.
- * @param patchContent - The full patch content
- * @param targetFile - The file path to check
- * @returns true if the patch creates targetFile as a new file
+ * Un-escapes a path from git's C-style quoted form (`"a/pfad m\303\244..."`).
+ * Handles the escapes git emits: `\\`, `\"`, `\t`, `\n`, `\r` and three-digit
+ * octal byte escapes. Octal bytes are decoded through a byte buffer so
+ * multibyte UTF-8 sequences (git's default `core.quotePath=true` encodes any
+ * non-ASCII path this way) come back as the real characters.
  */
-export function isNewFileInPatch(patchContent, targetFile) {
-    const lines = patchContent.split('\n');
-    let inTargetFile = false;
-    for (const line of lines) {
-        if (line.startsWith('diff --git')) {
-            const match = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-            inTargetFile = match?.[1] === targetFile;
+function unquoteGitPath(quoted) {
+    const bytes = [];
+    for (let i = 0; i < quoted.length; i++) {
+        const ch = quoted[i];
+        if (ch !== '\\') {
+            // Plain character — may itself be multi-byte when the diff already
+            // contains raw UTF-8; push its bytes.
+            const encoded = Buffer.from(quoted[i] ?? '', 'utf-8');
+            for (const b of encoded)
+                bytes.push(b);
             continue;
         }
-        if (!inTargetFile)
-            continue;
-        // Found hunk header — stop scanning metadata for this file section
-        if (line.startsWith('@@'))
+        const next = quoted[i + 1];
+        if (next === undefined)
             break;
-        if (line.startsWith('new file mode ')) {
-            return true;
+        if (next >= '0' && next <= '7') {
+            const octal = quoted.slice(i + 1, i + 4);
+            bytes.push(parseInt(octal, 8));
+            i += 3;
+            continue;
         }
+        const mapped = next === 'n' ? 0x0a : next === 't' ? 0x09 : next === 'r' ? 0x0d : next.charCodeAt(0);
+        bytes.push(mapped);
+        i += 1;
     }
-    return false;
+    return Buffer.from(bytes).toString('utf-8');
 }
 /**
- * Extracts affected file paths from a diff/patch content.
- * @param diffContent - The diff content to parse
- * @returns Array of file paths
+ * 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 function extractAffectedFiles(diffContent) {
-    const files = new Set();
-    const lines = diffContent.split('\n');
-    for (const line of lines) {
-        // Match "diff --git a/path/to/file b/path/to/file"
-        const diffMatch = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-        if (diffMatch?.[1]) {
-            files.add(diffMatch[1]);
-            continue;
-        }
-        // Match "+++ b/path/to/file" for new files
-        const addMatch = /^\+\+\+ b\/(.+)$/.exec(line);
-        if (addMatch?.[1] && addMatch[1] !== '/dev/null') {
-            files.add(addMatch[1]);
+export function parseDiffGitHeader(line) {
+    const stripped = line.endsWith('\r') ? line.slice(0, -1) : line;
+    if (!stripped.startsWith('diff --git '))
+        return null;
+    const body = stripped.slice('diff --git '.length);
+    // Quoted form (either or both sides may be quoted).
+    const quoted = /^(?:"a\/((?:[^"\\]|\\.)*)"|a\/(\S+)) (?:"b\/((?:[^"\\]|\\.)*)"|b\/(.+))$/.exec(body);
+    if (quoted && (quoted[1] !== undefined || quoted[3] !== undefined)) {
+        const sourcePath = quoted[1] !== undefined ? unquoteGitPath(quoted[1]) : (quoted[2] ?? '');
+        const targetPath = quoted[3] !== undefined ? unquoteGitPath(quoted[3]) : (quoted[4] ?? '');
+        return { sourcePath, targetPath };
+    }
+    if (!body.startsWith('a/'))
+        return null;
+    const rest = body.slice(2);
+    // Symmetric split: body === `a/<p> b/<p>`. Correct even when <p>
+    // contains ` b/`, which defeats any single-regex approach.
+    if ((rest.length - 3) % 2 === 0) {
+        const pathLength = (rest.length - 3) / 2;
+        const candidate = rest.slice(0, pathLength);
+        if (rest === `${candidate} b/${candidate}`) {
+            return { sourcePath: candidate, targetPath: candidate };
         }
     }
-    return Array.from(files).sort();
+    // Rename/copy (differing paths): non-greedy split at the first ` b/`.
+    const asymmetric = /^(.+?) b\/(.+)$/.exec(rest);
+    if (asymmetric?.[1] !== undefined && asymmetric[2] !== undefined) {
+        return { sourcePath: asymmetric[1], targetPath: asymmetric[2] };
+    }
+    return null;
 }
 /**
- * Parses hunks from a patch file for a specific target file.
- * @param patchContent - The full patch content
- * @param targetFile - The file path to extract hunks for
- * @returns Array of hunk objects with line info and changes
+ * Splits raw diff content into lines, tolerating CRLF-saved patch files.
+ *
+ * The distinction matters: a patch file saved with CRLF endings (Windows
+ * editor, `core.autocrlf` checkout) has `\r` on EVERY line including
+ * structural ones — strip it, or headers, `@@` lines and the
+ * `` marker all fail to match. But an LF patch
+ * of a file whose CONTENT is CRLF has `\r` only on payload lines, where it
+ * is significant and must be preserved. Detect the former by checking the
+ * structural lines themselves for a trailing `\r`.
  */
-export function parseHunksForFile(patchContent, targetFile) {
-    const hunks = [];
-    const lines = patchContent.split('\n');
-    let inTargetFile = false;
+function splitDiffLines(diffContent) {
+    const lines = diffContent.split('\n');
+    const isCrlfPatchFile = lines.some((line) => (line.startsWith('diff --git') || line.startsWith('@@ ')) &&
+        line.endsWith('\r') &&
+        line.length > 1);
+    if (!isCrlfPatchFile)
+        return lines;
+    return lines.map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
+}
+/**
+ * Parses a unified diff into structured per-file sections — the single
+ * shared walker every diff consumer builds on.
+ */
+export function parseDiffSections(diffContent) {
+    const sections = [];
+    const lines = splitDiffLines(diffContent);
+    let current = null;
     let currentHunk = null;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        // Check for diff header
-        if (line.startsWith('diff --git')) {
-            // Check if this is for our target file
-            const match = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-            if (currentHunk) {
-                hunks.push(currentHunk);
-            }
-            inTargetFile = match?.[1] === targetFile;
-            currentHunk = null;
+    const finishHunk = () => {
+        if (current && currentHunk) {
+            current.hunks.push(currentHunk);
+        }
+        currentHunk = null;
+    };
+    for (const line of lines) {
+        const header = parseDiffGitHeader(line);
+        if (header) {
+            finishHunk();
+            current = {
+                targetPath: header.targetPath,
+                sourcePath: header.sourcePath,
+                isNewFile: false,
+                isDeletedFile: false,
+                isBinary: false,
+                hunks: [],
+            };
+            sections.push(current);
             continue;
         }
-        if (!inTargetFile)
+        if (!current)
+            continue;
+        if (currentHunk === null) {
+            // File metadata zone (between the header and the first hunk).
+            if (line.startsWith('new file mode')) {
+                current.isNewFile = true;
+                continue;
+            }
+            if (line.startsWith('deleted file mode')) {
+                current.isDeletedFile = true;
+                continue;
+            }
+            if (line === 'GIT binary patch' || /^Binary files .* differ$/.test(line)) {
+                current.isBinary = true;
+                continue;
+            }
+        }
+        if (current.isBinary)
             continue;
-        // Check for hunk header
         const hunkMatch = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
         if (hunkMatch) {
-            if (currentHunk) {
-                hunks.push(currentHunk);
-            }
+            finishHunk();
             currentHunk = {
                 oldStart: parseInt(hunkMatch[1] ?? '0', 10),
                 oldCount: parseInt(hunkMatch[2] ?? '1', 10),
@@ -109,41 +186,82 @@ export function parseHunksForFile(patchContent, targetFile) {
             };
             continue;
         }
-        // Collect hunk lines
-        if (currentHunk) {
-            if (line === '\') {
-                // The marker is an annotation on the immediately preceding body
-                // line. Peek the last collected line to decide which side(s) the
-                // annotation applies to — a single boolean cannot represent the
-                // asymmetric case where only one side lacks the trailing newline.
-                const previous = currentHunk.lines[currentHunk.lines.length - 1] ?? '';
-                if (previous.startsWith('-')) {
-                    currentHunk.noNewlineAtEndOld = true;
-                }
-                else if (previous.startsWith('+')) {
-                    currentHunk.noNewlineAtEndNew = true;
-                }
-                else if (previous.startsWith(' ')) {
-                    // Context line: present in both sides, so the trailing-newline
-                    // absence applies to both. This is rare (it only happens when
-                    // the hunk ends on an unchanged line that itself is the last
-                    // line of the file) but real — git emits it.
-                    currentHunk.noNewlineAtEndOld = true;
-                    currentHunk.noNewlineAtEndNew = true;
-                }
-                // If the marker appears with no preceding body line (malformed
-                // diff), leave both flags false — the downstream apply logic
-                // will still produce a defined result.
+        if (!currentHunk)
+            continue;
+        if (line === '\') {
+            // The marker is an annotation on the immediately preceding body
+            // line. Peek the last collected line to decide which side(s) the
+            // annotation applies to — a single boolean cannot represent the
+            // asymmetric case where only one side lacks the trailing newline.
+            const previous = currentHunk.lines[currentHunk.lines.length - 1] ?? '';
+            if (previous.startsWith('-')) {
+                currentHunk.noNewlineAtEndOld = true;
+            }
+            else if (previous.startsWith('+')) {
+                currentHunk.noNewlineAtEndNew = true;
             }
-            else if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
-                currentHunk.lines.push(line);
+            else if (previous.startsWith(' ')) {
+                // Context line: present in both sides, so the trailing-newline
+                // absence applies to both. This is rare (it only happens when
+                // the hunk ends on an unchanged line that itself is the last
+                // line of the file) but real — git emits it.
+                currentHunk.noNewlineAtEndOld = true;
+                currentHunk.noNewlineAtEndNew = true;
             }
+            // If the marker appears with no preceding body line (malformed
+            // diff), leave both flags false — the downstream apply logic
+            // will still produce a defined result.
+            continue;
+        }
+        if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+            currentHunk.lines.push(line);
         }
     }
-    if (currentHunk) {
-        hunks.push(currentHunk);
+    finishHunk();
+    return sections;
+}
+/**
+ * Checks whether a specific file is a new-file addition within a patch.
+ * For multi-file patches, only inspects the section belonging to targetFile.
+ * @param patchContent - The full patch content
+ * @param targetFile - The file path to check
+ * @returns true if the patch creates targetFile as a new file
+ */
+export function isNewFileInPatch(patchContent, targetFile) {
+    return parseDiffSections(patchContent).some((section) => section.targetPath === targetFile && section.isNewFile);
+}
+/**
+ * Extracts affected file paths from a diff/patch content.
+ * @param diffContent - The diff content to parse
+ * @returns Array of file paths
+ */
+export function extractAffectedFiles(diffContent) {
+    const files = new Set();
+    for (const section of parseDiffSections(diffContent)) {
+        files.add(section.targetPath);
+    }
+    if (files.size === 0) {
+        // Header-less unified diff (no `diff --git` lines, e.g. hand-written
+        // or `diff -u` output): fall back to the `+++ b/<path>` markers.
+        for (const line of splitDiffLines(diffContent)) {
+            const addMatch = /^\+\+\+ b\/(.+)$/.exec(line);
+            if (addMatch?.[1] && addMatch[1] !== '/dev/null') {
+                files.add(addMatch[1]);
+            }
+        }
     }
-    return hunks;
+    return Array.from(files).sort();
+}
+/**
+ * Parses hunks from a patch file for a specific target file.
+ * @param patchContent - The full patch content
+ * @param targetFile - The file path to extract hunks for
+ * @returns Array of hunk objects with line info and changes
+ */
+export function parseHunksForFile(patchContent, targetFile) {
+    return parseDiffSections(patchContent)
+        .filter((section) => section.targetPath === targetFile)
+        .flatMap((section) => section.hunks);
 }
 /**
  * Extracts conflicting file paths from git apply error message.
@@ -162,4 +280,3 @@ export function extractConflictingFiles(error) {
     }
     return files;
 }
-//# sourceMappingURL=patch-parse.js.map

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

@@ -376,4 +376,3 @@ export function allocatePolicyOrder(config, patches, category) {
     }
     return null;
 }
-//# sourceMappingURL=patch-policy.js.map

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

@@ -14,6 +14,7 @@
  * references (widget tag names, locale fluent names). Unrelated jar.mn
  * or customElements.js edits pass through without spurious warnings.
  */
+import { parseDiffSections } from './patch-parse.js';
 /** Canonical file paths that registration-shaped diffs touch. */
 const REGISTRATION_FILE_PATHS = new Set([
     'toolkit/content/customElements.js',
@@ -36,32 +37,22 @@ export function collectPatchRegistrationReferences(patchBody) {
     if (!patchBody)
         return [];
     const refs = [];
-    let currentFile;
-    // Walk line-by-line. The canonical unified-diff header line is
-    // `diff --git a/<path> b/<path>` — we key the file state off the `b/`
-    // path because that names the target side and is stable against
-    // renames. Additional diff metadata lines (index/---/+++/@@) are
-    // ignored for the purposes of tracking the current file.
-    const lines = patchBody.split(/\r?\n/);
-    for (const line of lines) {
-        const diffHeader = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
-        if (diffHeader?.[2]) {
-            currentFile = diffHeader[2];
+    // Key the file state off the `b/` path because that names the target
+    // side and is stable against renames. Only real hunk adds count —
+    // parseDiffSections has already filtered out header/metadata lines.
+    for (const section of parseDiffSections(patchBody)) {
+        if (!REGISTRATION_FILE_PATHS.has(section.targetPath))
             continue;
-        }
-        if (!currentFile)
-            continue;
-        if (!REGISTRATION_FILE_PATHS.has(currentFile))
-            continue;
-        if (!line.startsWith('+'))
-            continue;
-        // Skip the `+++ b/<path>` header line — only real hunk adds count.
-        if (line.startsWith('+++'))
-            continue;
-        const added = line.slice(1);
-        const extracted = extractTargetPathsFromRegistrationLine(currentFile, added);
-        for (const target of extracted) {
-            refs.push({ targetPath: target, source: currentFile, lineText: added });
+        for (const hunk of section.hunks) {
+            for (const line of hunk.lines) {
+                if (!line.startsWith('+'))
+                    continue;
+                const added = line.slice(1);
+                const extracted = extractTargetPathsFromRegistrationLine(section.targetPath, added);
+                for (const target of extracted) {
+                    refs.push({ targetPath: target, source: section.targetPath, lineText: added });
+                }
+            }
         }
     }
     return refs;
@@ -114,4 +105,3 @@ function extractTargetPathsFromRegistrationLine(sourceFile, added) {
     }
     return [];
 }
-//# sourceMappingURL=patch-registration-refs.js.map

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

@@ -14,4 +14,3 @@ export function getPatchSourceVersion(patch) {
 export function getPatchSourceProduct(patch) {
     return patch.sourceProduct;
 }
-//# sourceMappingURL=patch-source-metadata.js.map

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

@@ -12,6 +12,10 @@
  * @param diff - Raw unified-diff content
  * @param targetFile - Optional target file to scope extraction to
  * @returns The file content that the patch would create
+ * @throws PatchError for binary sections — a `GIT binary patch` payload is
+ *   base85 (whose alphabet includes `+`), so "extract the + lines" would
+ *   silently write garbage text over a binary target. Callers must treat
+ *   binary new-file conflicts as unresolvable rather than auto-resolving.
  */
 export declare function extractNewFileContentFromDiff(diff: string, targetFile?: string): string;
 /**

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

@@ -5,7 +5,7 @@
  */
 import { PatchError } from '../errors/patch.js';
 import { readText } from '../utils/fs.js';
-import { isNewFileInPatch, parseHunksForFile } from './patch-parse.js';
+import { isNewFileInPatch, parseDiffSections, parseHunksForFile } from './patch-parse.js';
 /**
  * Extracts the complete file content from a "new file" patch given a raw
  * diff string already in memory. Callers with a patch file path should
@@ -16,48 +16,37 @@ import { isNewFileInPatch, parseHunksForFile } from './patch-parse.js';
  * @param diff - Raw unified-diff content
  * @param targetFile - Optional target file to scope extraction to
  * @returns The file content that the patch would create
+ * @throws PatchError for binary sections — a `GIT binary patch` payload is
+ *   base85 (whose alphabet includes `+`), so "extract the + lines" would
+ *   silently write garbage text over a binary target. Callers must treat
+ *   binary new-file conflicts as unresolvable rather than auto-resolving.
  */
 export function extractNewFileContentFromDiff(diff, targetFile) {
-    const lines = diff.split('\n');
+    const sections = parseDiffSections(diff).filter((section) => !targetFile || section.targetPath === targetFile);
+    const binary = sections.find((section) => section.isBinary);
+    if (binary) {
+        throw new PatchError(`Cannot extract text content from binary patch section for ${binary.targetPath}`, binary.targetPath);
+    }
+    // An empty new file is a legitimate git diff: `new file mode` with no
+    // hunks at all. It must extract as '' — the historical line-walker
+    // returned '\n' for it, creating a one-byte file that failed checksum
+    // and drift comparisons against the truly empty file the patch creates.
+    const hunks = sections.flatMap((section) => section.hunks);
+    if (hunks.length === 0) {
+        return '';
+    }
     const contentLines = [];
-    let inHunk = false;
-    let inTargetFile = !targetFile; // If no targetFile, accept all sections
-    let hasNoNewlineMarker = false;
-    for (const line of lines) {
-        // Track which file section we're in
-        if (line.startsWith('diff --git')) {
-            if (targetFile) {
-                const match = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-                const wasInTarget = inTargetFile;
-                inTargetFile = match?.[1] === targetFile;
-                // If we were in the target file and hit a new diff header, we're done
-                if (wasInTarget && !inTargetFile)
-                    break;
-            }
-            inHunk = false;
-            continue;
-        }
-        if (!inTargetFile)
-            continue;
-        // Start of hunk
-        if (line.startsWith('@@')) {
-            inHunk = true;
-            continue;
-        }
-        if (inHunk) {
-            // Check for "No newline at end of file" marker
-            if (line === '\') {
-                hasNoNewlineMarker = true;
-                continue;
-            }
-            // Lines starting with + are added content (skip the + prefix)
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            // Lines starting with + are added content (skip the + prefix).
+            // `-`/context lines shouldn't exist in new-file patches.
             if (line.startsWith('+')) {
                 contentLines.push(line.slice(1));
             }
-            // Lines starting with - are removed (shouldn't exist in new file patches)
-            // Context lines (no prefix) shouldn't exist in new file patches
         }
     }
+    const lastHunk = hunks[hunks.length - 1];
+    const hasNoNewlineMarker = lastHunk?.noNewlineAtEndNew ?? false;
     // Join lines and handle trailing newline
     const result = contentLines.join('\n');
     return hasNoNewlineMarker ? result : result + '\n';
@@ -129,8 +118,12 @@ export async function applyPatchToContent(content, patchPath, targetFile) {
         if (actualOldCount !== hunk.oldCount) {
             throw new PatchError(`Patch hunk header mismatch for ${targetFile}: header says ${hunk.oldCount} old lines but body has ${actualOldCount}`, targetFile);
         }
-        // Replace the old lines with new lines
-        const startIndex = hunk.oldStart - 1;
+        // Replace the old lines with new lines. Unified-diff convention: for a
+        // pure-insertion hunk (`@@ -N,0 +M,k @@`), N names the line BEFORE the
+        // insertion point, so content is spliced at index N (after line N) —
+        // `N - 1` inserted one line too early, and `@@ -0,0` (insert at top of
+        // file) produced splice(-1, …), which inserts before the LAST element.
+        const startIndex = hunk.oldCount === 0 ? hunk.oldStart : hunk.oldStart - 1;
         // Verify context lines match before applying
         let verifyIndex = startIndex;
         for (const hunkLine of hunk.lines) {
@@ -152,4 +145,3 @@ export async function applyPatchToContent(content, patchPath, targetFile) {
     }
     return contentLines.join('\n') + '\n';
 }
-//# sourceMappingURL=patch-transform.js.map

package/dist/src/core/rebase-session.js

@@ -62,4 +62,3 @@ export async function clearRebaseSession(projectRoot) {
 export async function hasActiveRebaseSession(projectRoot) {
     return pathExists(sessionPath(projectRoot));
 }
-//# sourceMappingURL=rebase-session.js.map

package/dist/src/core/register-browser-content.js

@@ -113,4 +113,3 @@ export async function registerBrowserContent(engineDir, fileName, after, sourceP
         afterFallback: value.afterFallback,
     };
 }
-//# sourceMappingURL=register-browser-content.js.map

package/dist/src/core/register-module.js

@@ -86,4 +86,3 @@ export async function registerFireForgeModule(engineDir, fileName, moduleDir, dr
     }
     return { manifest, entry, previousEntry: value.previousEntry, skipped: false };
 }
-//# sourceMappingURL=register-module.js.map

package/dist/src/core/register-result.js

@@ -6,4 +6,3 @@
  * type-only back-edge made the registration dependency graph cyclic.
  */
 export {};
-//# sourceMappingURL=register-result.js.map

package/dist/src/core/register-scaffold.js

@@ -143,4 +143,3 @@ export async function ensureXpcshellManifestWiring(engineDir, manifestRelPath, d
         dirRel = dirname(dirRel).replace(/\\/g, '/');
     }
 }
-//# sourceMappingURL=register-scaffold.js.map

package/dist/src/core/register-shared-css.js

@@ -178,4 +178,3 @@ export async function registerSharedCSS(engineDir, fileName, after, dryRun = fal
         afterFallback: value.afterFallback,
     };
 }
-//# sourceMappingURL=register-shared-css.js.map

package/dist/src/core/register-test-manifest.js

@@ -98,4 +98,3 @@ export async function deregisterTestManifest(engineDir, testDir) {
     await writeText(manifestPath, filtered.join('\n'));
     return true;
 }
-//# sourceMappingURL=register-test-manifest.js.map

package/dist/src/core/register-xpcshell-test.js

@@ -93,4 +93,3 @@ export async function registerXpcshellTest(engineDir, dirRel, fileName, dryRun =
     }
     return { manifest: manifestRel, entry, skipped: false };
 }
-//# sourceMappingURL=register-xpcshell-test.js.map

package/dist/src/core/shared-ftl.js

@@ -39,4 +39,3 @@ export function validateSharedFtl(raw, context) {
     }
     return { ok: true, value };
 }
-//# sourceMappingURL=shared-ftl.js.map

package/dist/src/core/signal-critical.js

@@ -62,4 +62,3 @@ export async function waitForActiveCriticalSections(timeoutMs) {
         new Promise((resolve) => setTimeout(resolve, timeoutMs)),
     ]);
 }
-//# sourceMappingURL=signal-critical.js.map

package/dist/src/core/smoke-patterns.js

@@ -97,4 +97,3 @@ export function compileAllowlistFromStrings(sources) {
     });
     return compiled;
 }
-//# sourceMappingURL=smoke-patterns.js.map

package/dist/src/core/state-file.js

@@ -22,4 +22,3 @@ export async function quarantineStateFile(statePath, reason = 'corrupt') {
     await rename(statePath, quarantinedPath);
     return basename(quarantinedPath);
 }
-//# sourceMappingURL=state-file.js.map

package/dist/src/core/status-classify.d.ts

@@ -41,6 +41,22 @@ export interface ClassifiedFile extends StatusFile {
      */
     claimedBy?: string[];
 }
+/**
+ * Builds the file → owning-patch-filenames multimap from manifest rows.
+ * Single source of truth for cross-patch claim detection — status
+ * classification, verify's cross-claim check, and the ownership table all
+ * consume this builder (they used to each rebuild it, one drift away from
+ * disagreeing about what "claimed" means).
+ */
+export declare function buildPatchClaims(manifestPatches: ReadonlyArray<{
+    filename: string;
+    filesAffected: string[];
+}>): Map<string, string[]>;
+/**
+ * Reduces a two-character porcelain XY status to its primary code.
+ * Single source of truth — status-output.ts renders from the same logic.
+ */
+export declare function getPrimaryStatusCode(status: string): string;
 /**
  * Classifies files into patch-backed, unmanaged, branding, furnace, or
  * conflict buckets.