@hominis/fireforge 0.54.0 → 0.60.0

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

@@ -1,13 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Patches manifest: re-exports from focused sub-modules.
- *
- * Callers should continue to import from this module. The internal split
- * is an implementation detail.
- */
-export { rebuildPatchesManifest, recommendManifestRepair, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { repairPatchesFilesAffected, } from './patch-manifest-files-affected.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';

package/dist/src/core/patch-order-legal.d.ts

@@ -1,26 +0,0 @@
-/**
- * The earliest order a new patch can take after a given order, under the
- * queue's occupancy and `patchPolicy`.
- *
- * A refusal that says "export it as its own later patch" leaves the
- * operator to find a number that is free, inside the category's range, and
- * (with `allowGaps: false`) does not open a gap. Each wrong guess costs a
- * full export attempt. This answers it once, with the same policy
- * evaluation the export itself will run.
- */
-import type { PatchesManifest } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-/**
- * Smallest order strictly greater than `after` that no patch occupies and
- * that adds no order-related `patchPolicy` finding (collision, category
- * range, reserved range, numeric gap) for a `category` patch. A retired
- * slot counts as free, since a patch may fill it; a reservation does not,
- * since it is held for its owner's export. Returns null when no such
- * order exists inside the category's configured ranges.
- *
- * @param config - Project config (only `patchPolicy` is read)
- * @param manifest - Current manifest
- * @param category - Category the new patch would carry
- * @param after - The order the new patch must come after
- */
-export declare function earliestLegalOrderAfter(config: Pick<FireForgeConfig, 'patchPolicy'>, manifest: PatchesManifest, category: string, after: number): number | null;

package/dist/src/core/patch-order-legal.js

@@ -1,88 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The earliest order a new patch can take after a given order, under the
- * queue's occupancy and `patchPolicy`.
- *
- * A refusal that says "export it as its own later patch" leaves the
- * operator to find a number that is free, inside the category's range, and
- * (with `allowGaps: false`) does not open a gap. Each wrong guess costs a
- * full export attempt. This answers it once, with the same policy
- * evaluation the export itself will run.
- */
-import { formatPatchOrder } from './patch-parse.js';
-import { evaluatePatchPolicy } from './patch-policy.js';
-import { reservedOrderSet } from './patch-retired.js';
-/** Policy codes an order choice alone can trip. */
-const ORDER_CODES = new Set([
-    'order-collision',
-    'category-range',
-    'reserved-range',
-    'numeric-gap',
-]);
-/** Upper bound on the search when no policy range bounds it. */
-const UNBOUNDED_SEARCH = 1000;
-const GAP_ORDERS_PATTERN = /numeric gap\(s\): (?<orders>[^.]+)\./;
-/**
- * Order-related findings as comparable keys. A `numeric-gap` finding
- * becomes one key per missing order, so filling one gap of several reads as
- * removing a key rather than as a new, differently worded finding.
- */
-function orderIssueKeys(config, manifest) {
-    const keys = new Set();
-    for (const issue of evaluatePatchPolicy(config, manifest)) {
-        if (!ORDER_CODES.has(issue.code))
-            continue;
-        const gaps = issue.code === 'numeric-gap' ? GAP_ORDERS_PATTERN.exec(issue.message) : null;
-        if (gaps?.groups?.['orders'] === undefined) {
-            keys.add(`${issue.code}|${issue.message}`);
-            continue;
-        }
-        for (const order of gaps.groups['orders'].split(',')) {
-            keys.add(`numeric-gap|${issue.filename}|${order.trim()}`);
-        }
-    }
-    return keys;
-}
-/**
- * Smallest order strictly greater than `after` that no patch occupies and
- * that adds no order-related `patchPolicy` finding (collision, category
- * range, reserved range, numeric gap) for a `category` patch. A retired
- * slot counts as free, since a patch may fill it; a reservation does not,
- * since it is held for its owner's export. Returns null when no such
- * order exists inside the category's configured ranges.
- *
- * @param config - Project config (only `patchPolicy` is read)
- * @param manifest - Current manifest
- * @param category - Category the new patch would carry
- * @param after - The order the new patch must come after
- */
-export function earliestLegalOrderAfter(config, manifest, category, after) {
-    const occupied = new Set([
-        ...manifest.patches.map((patch) => patch.order),
-        ...reservedOrderSet(manifest),
-    ]);
-    const ranges = config.patchPolicy?.ranges.filter((range) => range.category === category) ?? [];
-    const limit = ranges.length > 0 ? Math.max(...ranges.map((range) => range.to)) : after + UNBOUNDED_SEARCH;
-    const baseline = config.patchPolicy ? orderIssueKeys(config, manifest) : new Set();
-    for (let order = after + 1; order <= limit; order++) {
-        if (occupied.has(order))
-            continue;
-        if (!config.patchPolicy)
-            return order;
-        const probe = {
-            filename: `${formatPatchOrder(order)}-${category}-probe.patch`,
-            order,
-            category,
-            name: 'probe',
-            description: 'probe',
-            createdAt: '',
-            sourceEsrVersion: '',
-            filesAffected: [],
-        };
-        const projected = { ...manifest, patches: [...manifest.patches, probe] };
-        const introduced = [...orderIssueKeys(config, projected)].filter((key) => !baseline.has(key));
-        if (introduced.length === 0)
-            return order;
-    }
-    return null;
-}

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

@@ -1,161 +0,0 @@
-/**
- * Renders a patch order as the zero-padded prefix used in filenames and in
- * every message that names an order.
- *
- * Eleven call sites across `patch-policy`, `patch-export`, `export-flow`,
- * `export-placement-policy` and `patch move-files` spelled this as
- * `String(order).padStart(3, '0')`, so the padding width lived in eleven
- * places while the filenames it has to agree with are produced in one.
- * @param order - Numeric patch order.
- * @param width - Prefix width. Defaults to the on-disk convention.
- * @returns The zero-padded order, e.g. `007`.
- */
-export declare function formatPatchOrder(order: number, width?: number): string;
-/**
- * Renders an inclusive order range the way `patchPolicy` diagnostics name it.
- * @param range - Inclusive `from`/`to` order bounds.
- * @returns The range label, e.g. `100-199`.
- */
-export declare function formatOrderRange(range: {
-    from: number;
-    to: number;
-}): string;
-/**
- * Extracts the order number from a patch filename.
- * Expects format like "001-description.patch"
- * @param filename - Patch filename
- * @returns Order number, or Infinity if no prefix
- */
-export declare function extractOrder(filename: string): number;
-/**
- * Extracts the order number from a patch filename that is about to be
- * written into the manifest.
- *
- * The write-side counterpart to {@link extractOrder}. That one answers
- * `Infinity` for a prefix-less filename, which sorts such a patch last and
- * is the right answer for a read: an unparseable name should not crash a
- * status listing. Persisting `Infinity` (or a fallback `0`) is a different
- * matter: it puts an order in the manifest
- * that no filename on disk agrees with, and the queue then applies in an
- * order the operator cannot see. Callers here have just built or
- * looked up a real prefixed filename, so absence is a bug, not input.
- *
- * @param filename - Patch filename carrying a numeric order prefix
- * @returns The parsed order
- * @throws {@link InternalInvariantError} when `filename` has no numeric prefix.
- */
-export declare function requirePatchOrder(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: a greedy `a\/.+ b\/(.+)$` splits such
- * lines at the last ` b/` and returns 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;
-    /**
-     * True only for `GIT binary patch` sections, whose body carries a
-     * reconstructable literal/delta payload. False for `Binary files … differ`,
-     * which records that the bytes changed but carries none of them and cannot
-     * be replayed by `git apply`.
-     *
-     * The distinction is not cosmetic: the stub form still carries a correct
-     * `index <old>..<new>` line, so identity checks keyed on {@link indexNewHash}
-     * alone happily conclude "the recorded bytes match the live file" for a body
-     * that can no longer produce those bytes. Consumers deciding whether a patch
-     * can recreate a file must read this flag, never `isBinary` plus a hash.
-     */
-    hasBinaryDelta: boolean;
-    /**
-     * Old-side blob hash from the section's `index <old>..<new>` line
-     * (possibly abbreviated). Undefined when the metadata zone carries no
-     * parseable index line (hand-written diffs, `Binary files … differ`).
-     */
-    indexOldHash?: string;
-    /** New-side blob hash from the `index` line. See {@link indexOldHash}. */
-    indexNewHash?: string;
-    /** Parsed hunks, in file order. Empty for binary or metadata-only sections. */
-    hunks: ParsedHunk[];
-}
-/**
- * Parses a unified diff into structured per-file sections. This is 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.
- * @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 declare function isNewFileInPatch(patchContent: string, targetFile: string): boolean;
-/**
- * Extracts affected file paths from a diff/patch content.
- * @param diffContent - The diff content to parse
- * @returns Array of file paths
- */
-export declare function extractAffectedFiles(diffContent: string): string[];
-/**
- * A single parsed hunk. `noNewlineAtEndOld` / `noNewlineAtEndNew` track the
- * `` marker per side. The marker is a trailing
- * annotation on the immediately preceding body line, and a `-` precedent
- * sets only the old-side flag, a `+` sets only the new-side flag, and a
- * context ` ` line sets both. Collapsing the two into one boolean makes the
- * projection disagree with `git apply` on asymmetric trailing-newline
- * changes (e.g. removing a newline on one side but not the other).
- */
-export interface ParsedHunk {
-    oldStart: number;
-    oldCount: number;
-    newStart: number;
-    newCount: number;
-    lines: string[];
-    noNewlineAtEndOld: boolean;
-    noNewlineAtEndNew: boolean;
-}
-/**
- * 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 declare function parseHunksForFile(patchContent: string, targetFile: string): ParsedHunk[];
-/**
- * Extracts conflicting file paths from git apply error message.
- */
-export declare function extractConflictingFiles(error?: string): string[];

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

@@ -1,347 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { assert } from '../utils/assert.js';
-/**
- * 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. Hand-rolled
- * `diff --git` walkers diverge in ways that matter: CRLF handling (a
- * CRLF-saved patch file silently fails target-file matching and
- * `\ No newline` detection on Windows), 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.
- */
-/** Width of the zero-padded numeric prefix on a patch filename ("001-…"). */
-const PATCH_ORDER_WIDTH = 3;
-/**
- * Renders a patch order as the zero-padded prefix used in filenames and in
- * every message that names an order.
- *
- * Eleven call sites across `patch-policy`, `patch-export`, `export-flow`,
- * `export-placement-policy` and `patch move-files` spelled this as
- * `String(order).padStart(3, '0')`, so the padding width lived in eleven
- * places while the filenames it has to agree with are produced in one.
- * @param order - Numeric patch order.
- * @param width - Prefix width. Defaults to the on-disk convention.
- * @returns The zero-padded order, e.g. `007`.
- */
-export function formatPatchOrder(order, width = PATCH_ORDER_WIDTH) {
-    return String(order).padStart(width, '0');
-}
-/**
- * Renders an inclusive order range the way `patchPolicy` diagnostics name it.
- * @param range - Inclusive `from`/`to` order bounds.
- * @returns The range label, e.g. `100-199`.
- */
-export function formatOrderRange(range) {
-    return `${formatPatchOrder(range.from)}-${formatPatchOrder(range.to)}`;
-}
-/**
- * Extracts the order number from a patch filename.
- * Expects format like "001-description.patch"
- * @param filename - Patch filename
- * @returns Order number, or Infinity if no prefix
- */
-export function extractOrder(filename) {
-    const match = /^(\d+)-/.exec(filename);
-    if (match?.[1]) {
-        return parseInt(match[1], 10);
-    }
-    return Infinity;
-}
-/**
- * Extracts the order number from a patch filename that is about to be
- * written into the manifest.
- *
- * The write-side counterpart to {@link extractOrder}. That one answers
- * `Infinity` for a prefix-less filename, which sorts such a patch last and
- * is the right answer for a read: an unparseable name should not crash a
- * status listing. Persisting `Infinity` (or a fallback `0`) is a different
- * matter: it puts an order in the manifest
- * that no filename on disk agrees with, and the queue then applies in an
- * order the operator cannot see. Callers here have just built or
- * looked up a real prefixed filename, so absence is a bug, not input.
- *
- * @param filename - Patch filename carrying a numeric order prefix
- * @returns The parsed order
- * @throws {@link InternalInvariantError} when `filename` has no numeric prefix.
- */
-export function requirePatchOrder(filename) {
-    const match = /^(\d+)-/.exec(filename);
-    assert(match?.[1] !== undefined, () => `patch filename carries a numeric order prefix (got "${filename}")`);
-    return parseInt(match[1], 10);
-}
-/**
- * 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.
- */
-function unquoteGitPath(quoted) {
-    const bytes = [];
-    for (let i = 0; i < quoted.length; i++) {
-        const ch = quoted[i];
-        if (ch !== '\\') {
-            // Plain character, which 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;
-        }
-        const next = quoted[i + 1];
-        if (next === undefined)
-            break;
-        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 Buffer.from(bytes).toString('utf-8');
-}
-/**
- * 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: a greedy `a\/.+ b\/(.+)$` splits such
- * lines at the last ` b/` and returns 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 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 };
-        }
-    }
-    // Rename/copy (differing paths): split at the first ` b/` with a path on
-    // each side. indexOf keeps this linear where a lazy regex backtracks.
-    if (/[\n\r\u2028\u2029]/.test(rest))
-        return null;
-    const split = rest.indexOf(' b/', 1);
-    if (split === -1 || split + 3 >= rest.length)
-        return null;
-    return { sourcePath: rest.slice(0, split), targetPath: rest.slice(split + 3) };
-}
-/**
- * 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`.
- */
-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. This is 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;
-    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,
-                hasBinaryDelta: false,
-                hunks: [],
-            };
-            sections.push(current);
-            continue;
-        }
-        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') {
-                current.isBinary = true;
-                current.hasBinaryDelta = true;
-                continue;
-            }
-            if (/^Binary files .* differ$/.test(line)) {
-                // Informational form: binary, but with no payload to apply.
-                current.isBinary = true;
-                continue;
-            }
-            // `git diff --binary` always records full blob hashes here (git
-            // apply requires them). Text sections carry abbreviated ones. The
-            // hashes let binary sections be compared by identity when their
-            // payload cannot be applied as text.
-            const indexMatch = /^index ([0-9a-f]{7,64})\.\.([0-9a-f]{7,64})(?: \d{6})?$/.exec(line);
-            if (indexMatch?.[1] !== undefined && indexMatch[2] !== undefined) {
-                current.indexOldHash = indexMatch[1];
-                current.indexNewHash = indexMatch[2];
-                continue;
-            }
-        }
-        if (current.isBinary)
-            continue;
-        const hunkMatch = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
-        if (hunkMatch) {
-            finishHunk();
-            currentHunk = {
-                oldStart: parseInt(hunkMatch[1] ?? '0', 10),
-                oldCount: parseInt(hunkMatch[2] ?? '1', 10),
-                newStart: parseInt(hunkMatch[3] ?? '0', 10),
-                newCount: parseInt(hunkMatch[4] ?? '1', 10),
-                lines: [],
-                noNewlineAtEndOld: false,
-                noNewlineAtEndNew: false,
-            };
-            continue;
-        }
-        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 (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);
-        }
-    }
-    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 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.
- */
-export function extractConflictingFiles(error) {
-    if (!error)
-        return [];
-    const files = [];
-    const lines = error.split('\n');
-    for (const line of lines) {
-        // Match "error: patch failed: path/to/file:line"
-        const match = /error: patch failed: ([^:]+)/.exec(line);
-        if (match?.[1]) {
-            files.push(match[1]);
-        }
-    }
-    return files;
-}

package/dist/src/core/patch-policy-content.d.ts

@@ -1,40 +0,0 @@
-/**
- * Registration-only patch policy: the `patchPolicy` rules that need the
- * patch bodies, not just the manifest.
- *
- * - `upstreamAllowlist`: which upstream files (files no patch in the queue
- *   creates) a non-reserved patch may modify.
- * - `addOnly` allowlist entries: for shared registration files, a patch may
- *   only add lines, and each non-blank added line must carry the marker.
- * - `scopeRules`: limit a class of patch (a category, or a filename pattern
- *   such as `-tests\.patch$`) to the files its globs name.
- * - `verifyDocumentPaths`: every reserved allowlist entry's `adr` /
- *   `documentation` path must exist.
- *
- * Every rule is opt-in, and none can be evaluated from `patches.json`
- * alone, which is why they live apart from `patch-policy.ts`: that module
- * answers synchronously over a (possibly projected) manifest, this one reads
- * patch bodies and the filesystem. `verify` and `lint --per-patch` run both.
- */
-import type { PatchesManifest } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-import { type PatchQueueEntry } from './patch-lint-cross.js';
-import type { PatchPolicyIssue } from './patch-policy.js';
-/** True when the policy sets any rule this module evaluates. */
-export declare function hasPatchPolicyContentRules(config: FireForgeConfig): boolean;
-/**
- * Evaluates the body-dependent `patchPolicy` rules over a patch queue.
- *
- * @param config - Project configuration
- * @param projectRoot - Project root, for the document-path check
- * @param manifest - Current manifest (category and order per patch)
- * @param entries - Patch queue entries with their bodies
- * @returns Findings, in the same shape {@link evaluatePatchPolicy} returns
- */
-export declare function evaluatePatchPolicyContent(config: FireForgeConfig, projectRoot: string, manifest: PatchesManifest, entries: readonly PatchQueueEntry[]): Promise<PatchPolicyIssue[]>;
-/**
- * {@link evaluatePatchPolicyContent} for a caller without a queue context
- * in hand (`verify`): reads the patch bodies only when a body-dependent
- * rule is configured.
- */
-export declare function evaluatePatchPolicyContentForQueue(config: FireForgeConfig, projectRoot: string, patchesDir: string, manifest: PatchesManifest): Promise<PatchPolicyIssue[]>;