@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/patch-registration-refs.d.ts

@@ -1,41 +0,0 @@
-/**
- * Extracts furnace-shaped registration references from a patch body.
- *
- * `export-all --exclude-furnace` can land a patch that registers a furnace
- * component (via edits to `toolkit/content/customElements.js`,
- * `toolkit/content/jar.mn`, or `toolkit/locales/jar.mn`) without including
- * the component's source files, and `fireforge verify` then reports "Verify
- * clean" for the broken queue. This module provides a pattern-scoped scan so
- * `verify` can cross-check registrations against available file bodies.
- *
- * The scan is narrow on purpose: it only matches component-shaped
- * references (widget tag names, locale fluent names). Unrelated jar.mn or
- * customElements.js edits pass through without spurious warnings.
- */
-/**
- * A referenced engine path extracted from a registration hunk, together
- * with where it came from. The `source` field lets `verify` point
- * operators at the specific consequence file whose hunk introduced the
- * reference.
- */
-export interface PatchRegistrationReference {
-    /** Engine-relative path that the registration hunk adds a reference to. */
-    targetPath: string;
-    /** The registration file that contained the added hunk. */
-    source: string;
-    /** Raw hunk line that produced the reference, for diagnostic context. */
-    lineText: string;
-}
-/**
- * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch adds a registration for.
- *
- * Returns the empty array when no registration hunks are present, or
- * when the registration hunks do not mention any component-shaped
- * paths. That leaves the scan silent on the vast majority of patches
- * (branding tweaks, behavioural fixes, module additions) so it only
- * fires when a furnace-managed component is being newly registered.
- *
- * @param patchBody - Full unified-diff body of the patch file.
- */
-export declare function collectPatchRegistrationReferences(patchBody: string): PatchRegistrationReference[];

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

@@ -1,107 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Extracts furnace-shaped registration references from a patch body.
- *
- * `export-all --exclude-furnace` can land a patch that registers a furnace
- * component (via edits to `toolkit/content/customElements.js`,
- * `toolkit/content/jar.mn`, or `toolkit/locales/jar.mn`) without including
- * the component's source files, and `fireforge verify` then reports "Verify
- * clean" for the broken queue. This module provides a pattern-scoped scan so
- * `verify` can cross-check registrations against available file bodies.
- *
- * The scan is narrow on purpose: it only matches component-shaped
- * references (widget tag names, locale fluent names). Unrelated jar.mn or
- * customElements.js edits pass through without spurious warnings.
- */
-import { WIDGETS_DIR } from './furnace-constants.js';
-import { parseDiffSections } from './patch-parse.js';
-/** Canonical file paths that registration-shaped diffs touch. */
-const REGISTRATION_FILE_PATHS = new Set([
-    'toolkit/content/customElements.js',
-    'toolkit/content/jar.mn',
-    'toolkit/locales/jar.mn',
-]);
-/**
- * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch adds a registration for.
- *
- * Returns the empty array when no registration hunks are present, or
- * when the registration hunks do not mention any component-shaped
- * paths. That leaves the scan silent on the vast majority of patches
- * (branding tweaks, behavioural fixes, module additions) so it only
- * fires when a furnace-managed component is being newly registered.
- *
- * @param patchBody - Full unified-diff body of the patch file.
- */
-export function collectPatchRegistrationReferences(patchBody) {
-    if (!patchBody)
-        return [];
-    const refs = [];
-    // 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;
-        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;
-}
-/**
- * Per-source extractor. Each registration file has a distinct syntactic
- * shape. We scope the match to that file so a jar.mn regex does not
- * accidentally match a customElements.js line.
- */
-function extractTargetPathsFromRegistrationLine(sourceFile, added) {
-    if (sourceFile === 'toolkit/content/jar.mn') {
-        // Example (added line, leading `+` already stripped):
-        //   `   content/global/elements/moz-qa-panel.mjs  (widgets/moz-qa-panel/moz-qa-panel.mjs)`
-        // The parenthesised second half is the repo-relative path Firefox's
-        // packaging system reads. Widget registrations always live under
-        // `widgets/<tag>/<file>`, and the enclosing tree is
-        // `toolkit/content/widgets/`. Reconstruct the engine-relative
-        // target path so callers can check it against patch bodies.
-        const widgetMatch = /\(\s*(widgets\/[^\s)]+)\s*\)/.exec(added);
-        if (widgetMatch?.[1]) {
-            return [`toolkit/content/${widgetMatch[1]}`];
-        }
-        return [];
-    }
-    if (sourceFile === 'toolkit/locales/jar.mn') {
-        // Example:
-        //   `  locale/@AB_CD@/toolkit/global/moz-qa-panel.ftl (%toolkit/global/moz-qa-panel.ftl)`
-        // The `%`-prefixed repo-relative reference points at
-        // `toolkit/locales/en-US/<rel>`, which is the canonical FTL path.
-        const localeMatch = /\(%\s*([^\s)]+\.ftl)\s*\)/.exec(added);
-        if (localeMatch?.[1]) {
-            return [`toolkit/locales/en-US/${localeMatch[1]}`];
-        }
-        return [];
-    }
-    if (sourceFile === 'toolkit/content/customElements.js') {
-        // Example:
-        //   `          ["moz-qa-panel", "chrome://global/content/elements/moz-qa-panel.mjs"],`
-        // The chrome URL maps back to
-        // `toolkit/content/widgets/<tag>/<tag>.mjs` by convention: the
-        // packager rewrites `chrome://global/content/elements/<file>` to the
-        // widget tree root. The tag name is the identifier we key off.
-        const elementMatch = /\[\s*"([a-z][a-z0-9-]*)"\s*,\s*"chrome:\/\/global\/content\/elements\/([a-zA-Z0-9_-]+)\.mjs"\s*\]/.exec(added);
-        if (elementMatch?.[1] && elementMatch[2]) {
-            const tag = elementMatch[1];
-            const fileStem = elementMatch[2];
-            return [`${WIDGETS_DIR}/${tag}/${fileStem}.mjs`];
-        }
-        return [];
-    }
-    return [];
-}

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

@@ -1,57 +0,0 @@
-/**
- * Retired order slots: the placeholders `patch retire` leaves in
- * `patches.json#retired` so a patch can leave the queue without opening a
- * numeric gap or renumbering its successors.
- *
- * A slot is not a patch. It has no `.patch` file and no row in `patches`,
- * so everything that applies, exports, lints or rebases the queue walks past
- * it without knowing it exists. The one reader is the
- * `patchPolicy.allowGaps: false` gap check, which counts a retired order as
- * occupied. A patch that later takes the same order fills the slot, and
- * {@link carryRetiredSlots} drops it on that write, so the manifest never
- * holds a slot and a patch at one order.
- *
- * Reserved slots (`patch reserve`) follow the same rules: a placeholder for
- * an order a session has claimed but not exported yet, counted as occupied
- * by the gap check and filled (and dropped) by the export that lands on it.
- */
-import type { PatchesManifest, PatchMetadata, PatchReservedSlot, PatchRetiredSlot } from '../types/commands/index.js';
-/**
- * The retired slots of `current` that no patch in `patches` occupies, or
- * undefined when none remain. Every manifest write that rebuilds the
- * `patches` list routes the slots through here, so a slot survives the
- * rewrite and a filled one does not.
- *
- * @param current - Manifest the slots come from (null or slot-free: none)
- * @param patches - The rows the written manifest will hold
- */
-export declare function carryRetiredSlots(current: Pick<PatchesManifest, 'retired'> | null | undefined, patches: readonly Pick<PatchMetadata, 'order'>[]): PatchRetiredSlot[] | undefined;
-/**
- * Reserved twin of {@link carryRetiredSlots}: the reservations of `current`
- * that no patch in `patches` has filled yet.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export declare function carryReservedSlots(current: Pick<PatchesManifest, 'reserved'> | null | undefined, patches: readonly Pick<PatchMetadata, 'order'>[]): PatchReservedSlot[] | undefined;
-/**
- * Builds a manifest from `patches` that keeps `current`'s unfilled retired
- * and reserved slots. Each key is omitted entirely when no slot remains, so
- * a queue that never retired or reserved anything writes the same JSON as
- * before.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export declare function manifestWithRetiredSlots(current: Pick<PatchesManifest, 'retired' | 'reserved'> | null | undefined, patches: PatchMetadata[]): PatchesManifest;
-/** The set of order numbers held by retired slots. */
-export declare function retiredOrderSet(manifest: Pick<PatchesManifest, 'retired'>): Set<number>;
-/** The set of order numbers held by reserved slots. */
-export declare function reservedOrderSet(manifest: Pick<PatchesManifest, 'reserved'>): Set<number>;
-/**
- * The reservation at `order`, if any.
- *
- * @param manifest - Manifest to search (null: none)
- * @param order - Order number
- */
-export declare function reservationAt(manifest: Pick<PatchesManifest, 'reserved'> | null | undefined, order: number): PatchReservedSlot | undefined;

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

@@ -1,92 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Retired order slots: the placeholders `patch retire` leaves in
- * `patches.json#retired` so a patch can leave the queue without opening a
- * numeric gap or renumbering its successors.
- *
- * A slot is not a patch. It has no `.patch` file and no row in `patches`,
- * so everything that applies, exports, lints or rebases the queue walks past
- * it without knowing it exists. The one reader is the
- * `patchPolicy.allowGaps: false` gap check, which counts a retired order as
- * occupied. A patch that later takes the same order fills the slot, and
- * {@link carryRetiredSlots} drops it on that write, so the manifest never
- * holds a slot and a patch at one order.
- *
- * Reserved slots (`patch reserve`) follow the same rules: a placeholder for
- * an order a session has claimed but not exported yet, counted as occupied
- * by the gap check and filled (and dropped) by the export that lands on it.
- */
-/**
- * The retired slots of `current` that no patch in `patches` occupies, or
- * undefined when none remain. Every manifest write that rebuilds the
- * `patches` list routes the slots through here, so a slot survives the
- * rewrite and a filled one does not.
- *
- * @param current - Manifest the slots come from (null or slot-free: none)
- * @param patches - The rows the written manifest will hold
- */
-export function carryRetiredSlots(current, patches) {
-    const slots = current?.retired;
-    if (slots === undefined || slots.length === 0)
-        return undefined;
-    const occupied = new Set(patches.map((patch) => patch.order));
-    const kept = slots
-        .filter((slot) => !occupied.has(slot.order))
-        .map((slot) => ({ ...slot }))
-        .sort((a, b) => a.order - b.order);
-    return kept.length > 0 ? kept : undefined;
-}
-/**
- * Reserved twin of {@link carryRetiredSlots}: the reservations of `current`
- * that no patch in `patches` has filled yet.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export function carryReservedSlots(current, patches) {
-    const slots = current?.reserved;
-    if (slots === undefined || slots.length === 0)
-        return undefined;
-    const occupied = new Set(patches.map((patch) => patch.order));
-    const kept = slots
-        .filter((slot) => !occupied.has(slot.order))
-        .map((slot) => ({ ...slot }))
-        .sort((a, b) => a.order - b.order);
-    return kept.length > 0 ? kept : undefined;
-}
-/**
- * Builds a manifest from `patches` that keeps `current`'s unfilled retired
- * and reserved slots. Each key is omitted entirely when no slot remains, so
- * a queue that never retired or reserved anything writes the same JSON as
- * before.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export function manifestWithRetiredSlots(current, patches) {
-    const retired = carryRetiredSlots(current, patches);
-    const reserved = carryReservedSlots(current, patches);
-    return {
-        version: 1,
-        patches,
-        ...(retired !== undefined ? { retired } : {}),
-        ...(reserved !== undefined ? { reserved } : {}),
-    };
-}
-/** The set of order numbers held by retired slots. */
-export function retiredOrderSet(manifest) {
-    return new Set((manifest.retired ?? []).map((slot) => slot.order));
-}
-/** The set of order numbers held by reserved slots. */
-export function reservedOrderSet(manifest) {
-    return new Set((manifest.reserved ?? []).map((slot) => slot.order));
-}
-/**
- * The reservation at `order`, if any.
- *
- * @param manifest - Manifest to search (null: none)
- * @param order - Order number
- */
-export function reservationAt(manifest, order) {
-    return manifest?.reserved?.find((slot) => slot.order === order);
-}

package/dist/src/core/patch-source-metadata.d.ts

@@ -1,6 +0,0 @@
-import type { PatchMetadata } from '../types/commands/index.js';
-import type { FirefoxConfig } from '../types/config.js';
-/** Metadata fields stamped on new or refreshed patch entries. */
-export declare function buildPatchSourceMetadata(firefox: Pick<FirefoxConfig, 'product' | 'version'>): Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceProduct' | 'sourceVersion'>;
-/** Source version reader that also accepts rows carrying only `sourceEsrVersion`. */
-export declare function getPatchSourceVersion(patch: Pick<PatchMetadata, 'sourceEsrVersion' | 'sourceVersion'>): string;

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

@@ -1,12 +0,0 @@
-/** Metadata fields stamped on new or refreshed patch entries. */
-export function buildPatchSourceMetadata(firefox) {
-    return {
-        sourceEsrVersion: firefox.version,
-        sourceProduct: firefox.product,
-        sourceVersion: firefox.version,
-    };
-}
-/** Source version reader that also accepts rows carrying only `sourceEsrVersion`. */
-export function getPatchSourceVersion(patch) {
-    return patch.sourceVersion ?? patch.sourceEsrVersion;
-}

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

@@ -1,18 +0,0 @@
-import type { PatchesManifest, PatchMetadata } from '../types/commands/index.js';
-/**
- * Resolves a `--patches <name…>` subset against the manifest, matching each
- * requested name tolerantly (exact filename, filename ± `.patch`, the bare
- * order number, the manifest `name` field, or the slug). Accepts repeated
- * values and lists separated by commas or whitespace, so a list passed as
- * one shell word (`--patches "$P"` under zsh) still splits. Throws when a
- * requested name matches none, so a typo fails loud rather than silently
- * judging nothing; the refusal names that name and its nearest matches,
- * not the whole queue.
- *
- * @param manifest - The loaded patch manifest
- * @param requested - Raw `--patches` values (each may be a comma or whitespace list)
- * @param refusalHint - Sentence inserted into the no-match refusal, naming
- *   what the caller's flag selects
- * @returns The matching manifest rows, de-duplicated, in request order
- */
-export declare function selectPatchSubset(manifest: PatchesManifest, requested: readonly string[], refusalHint?: string): PatchMetadata[];

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

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The `--patches <name…>` subset resolver shared by `lint --per-patch`,
- * `status` and `verify`. One matcher, so a name that selects a patch in
- * one gate selects the same patch in the others.
- */
-import { GeneralError } from '../errors/base.js';
-import { formatPatchSuggestions } from './patch-identifier-suggest.js';
-/** Every spelling an operator may use for one patch. */
-function patchAliases(p) {
-    const aliases = new Set([p.filename, p.filename.replace(/\.patch$/, ''), p.name]);
-    // The bare order number, both as the manifest records it and as the
-    // filename spells it (`2` and `002`). The refusal message offers stems,
-    // and an operator reading `102-ui-canvas-tiles.patch` in a lint finding
-    // reaches for `102` first.
-    aliases.add(String(p.order));
-    const match = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(p.filename);
-    if (match?.[1])
-        aliases.add(match[1]);
-    if (match?.[2] && match[3]) {
-        aliases.add(`${match[2]}-${match[3]}`);
-        aliases.add(match[3]);
-    }
-    return aliases;
-}
-function matchesPatch(p, name) {
-    const aliases = patchAliases(p);
-    const stem = name.replace(/\.patch$/, '');
-    return aliases.has(name) || aliases.has(stem) || aliases.has(`${stem}.patch`);
-}
-/**
- * Resolves a `--patches <name…>` subset against the manifest, matching each
- * requested name tolerantly (exact filename, filename ± `.patch`, the bare
- * order number, the manifest `name` field, or the slug). Accepts repeated
- * values and lists separated by commas or whitespace, so a list passed as
- * one shell word (`--patches "$P"` under zsh) still splits. Throws when a
- * requested name matches none, so a typo fails loud rather than silently
- * judging nothing; the refusal names that name and its nearest matches,
- * not the whole queue.
- *
- * @param manifest - The loaded patch manifest
- * @param requested - Raw `--patches` values (each may be a comma or whitespace list)
- * @param refusalHint - Sentence inserted into the no-match refusal, naming
- *   what the caller's flag selects
- * @returns The matching manifest rows, de-duplicated, in request order
- */
-export function selectPatchSubset(manifest, requested, refusalHint = '') {
-    const normalizedRequests = requested
-        .flatMap((entry) => entry.split(/[\s,]+/))
-        .filter((entry) => entry.length > 0);
-    const selected = [];
-    const seen = new Set();
-    for (const name of normalizedRequests) {
-        const found = manifest.patches.filter((p) => matchesPatch(p, name));
-        if (found.length === 0) {
-            throw new GeneralError(`No patch in the queue matches "${name}".${refusalHint ? ` ${refusalHint}` : ''} ` +
-                formatPatchSuggestions(name, manifest.patches));
-        }
-        for (const p of found) {
-            if (!seen.has(p.filename)) {
-                seen.add(p.filename);
-                selected.push(p);
-            }
-        }
-    }
-    return selected;
-}

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

@@ -1,61 +0,0 @@
-/**
- * Pure content transformation functions for patch operations.
- * These operate on file content strings without filesystem side effects.
- */
-/**
- * Extracts the complete file content from a "new file" patch given a raw
- * diff string already in memory. A caller with only a patch file path
- * reads it first; every caller holds the diff already.
- *
- * @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;
-/**
- * {@link extractNewFileContentFromDiff} for many targets over one parse of
- * the diff. Each target gets exactly what the single-target call returns;
- * a target whose sections include a binary one (which that call refuses)
- * is left out of the map and named in `refused`.
- * @param diff - Raw unified-diff content
- * @param targetFiles - Files whose created content to extract
- */
-export declare function extractNewFileContentsFromDiff(diff: string, targetFiles: Iterable<string>): {
-    contents: Map<string, string>;
-    refused: string[];
-};
-/**
- * Projects every text new file a diff creates into a path → content map, for
- * the cross-patch lint projections that build a synthetic patch-queue entry.
- *
- * Binary new files are skipped rather than refused. The map feeds only the
- * forward-import rule, which scans content for import statements, and a
- * binary blob authors none, so omitting it contributes exactly what
- * including it would. Refusing instead (which is what
- * {@link extractNewFileContentFromDiff} correctly does for a caller that
- * named one file) made vendoring a new binary impossible: every projection
- * site fed it every detected new file, so `export --order`, `re-export
- * --scan --scan-file`, `patch move-files-into` and `patch split` all died on
- * a file the export half had just written a valid `GIT binary patch` for.
- * Nothing is lost by skipping: binary bodies are covered independently by the
- * `binary-body-not-reconstructable` queue lint, and
- * `buildPatchQueueContext` already tolerates them for real queue entries.
- *
- * One parse for the whole diff, rather than one per new file, shared by
- * every call site.
- */
-export declare function buildNewFileTextProjection(diff: string): Map<string, string>;
-/**
- * Applies an already-read patch body to content. Batched callers that hold
- * many (patch, file) pairs use this to read each patch body once instead of
- * once per pair.
- * @param content - Original content (null for new files)
- * @param patchContent - Full text of the patch body
- * @param targetFile - The file path within the patch
- * @returns Modified content
- */
-export declare function applyPatchTextToContent(content: string | null, patchContent: string, targetFile: string): string;

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

@@ -1,198 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Pure content transformation functions for patch operations.
- * These operate on file content strings without filesystem side effects.
- */
-import { PatchError } from '../errors/patch.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. A caller with only a patch file path
- * reads it first; every caller holds the diff already.
- *
- * @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 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);
-    }
-    return contentFromSections(sections);
-}
-/**
- * {@link extractNewFileContentFromDiff} for many targets over one parse of
- * the diff. Each target gets exactly what the single-target call returns;
- * a target whose sections include a binary one (which that call refuses)
- * is left out of the map and named in `refused`.
- * @param diff - Raw unified-diff content
- * @param targetFiles - Files whose created content to extract
- */
-export function extractNewFileContentsFromDiff(diff, targetFiles) {
-    const sectionsByTarget = new Map();
-    for (const section of parseDiffSections(diff)) {
-        const list = sectionsByTarget.get(section.targetPath) ?? [];
-        list.push(section);
-        sectionsByTarget.set(section.targetPath, list);
-    }
-    const contents = new Map();
-    const refused = [];
-    for (const target of targetFiles) {
-        const sections = sectionsByTarget.get(target) ?? [];
-        if (sections.some((section) => section.isBinary)) {
-            refused.push(target);
-            continue;
-        }
-        contents.set(target, contentFromSections(sections));
-    }
-    return { contents, refused };
-}
-/**
- * Walks the added (`+`) lines of already-parsed sections into file content.
- * Shared by {@link extractNewFileContentFromDiff} and
- * {@link buildNewFileTextProjection} so the two cannot drift on the empty-file
- * and no-trailing-newline cases below.
- */
-function contentFromSections(sections) {
-    // 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 = [];
-    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));
-            }
-        }
-    }
-    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';
-}
-/**
- * Projects every text new file a diff creates into a path → content map, for
- * the cross-patch lint projections that build a synthetic patch-queue entry.
- *
- * Binary new files are skipped rather than refused. The map feeds only the
- * forward-import rule, which scans content for import statements, and a
- * binary blob authors none, so omitting it contributes exactly what
- * including it would. Refusing instead (which is what
- * {@link extractNewFileContentFromDiff} correctly does for a caller that
- * named one file) made vendoring a new binary impossible: every projection
- * site fed it every detected new file, so `export --order`, `re-export
- * --scan --scan-file`, `patch move-files-into` and `patch split` all died on
- * a file the export half had just written a valid `GIT binary patch` for.
- * Nothing is lost by skipping: binary bodies are covered independently by the
- * `binary-body-not-reconstructable` queue lint, and
- * `buildPatchQueueContext` already tolerates them for real queue entries.
- *
- * One parse for the whole diff, rather than one per new file, shared by
- * every call site.
- */
-export function buildNewFileTextProjection(diff) {
-    const newFiles = new Map();
-    for (const section of parseDiffSections(diff)) {
-        if (!section.isNewFile || section.isBinary)
-            continue;
-        newFiles.set(section.targetPath, contentFromSections([section]));
-    }
-    return newFiles;
-}
-/**
- * Applies an already-read patch body to content. Batched callers that hold
- * many (patch, file) pairs use this to read each patch body once instead of
- * once per pair.
- * @param content - Original content (null for new files)
- * @param patchContent - Full text of the patch body
- * @param targetFile - The file path within the patch
- * @returns Modified content
- */
-export function applyPatchTextToContent(content, patchContent, targetFile) {
-    // Check if this is a new file patch for the target file specifically
-    if (content === null) {
-        if (isNewFileInPatch(patchContent, targetFile)) {
-            return extractNewFileContentFromDiff(patchContent, targetFile);
-        }
-        // If not a new file patch but content is null, return empty
-        return '';
-    }
-    const hunks = parseHunksForFile(patchContent, targetFile);
-    if (hunks.length === 0) {
-        return content;
-    }
-    // Apply hunks
-    const contentLines = content.split('\n');
-    // Remove trailing empty line if content ends with newline (but not for empty files)
-    if (contentLines.length > 1 && contentLines[contentLines.length - 1] === '') {
-        contentLines.pop();
-    }
-    // Process hunks in reverse order to preserve line numbers
-    const sortedHunks = [...hunks].sort((a, b) => b.oldStart - a.oldStart);
-    // The "no newline at end" marker applies to the last hunk in file order
-    // (highest oldStart), which is the *first* hunk in our reverse-sorted array.
-    // We read the new-side flag because the output we produce corresponds to
-    // the new side. Asymmetric diffs (old lacks newline, new has one, or
-    // vice versa) would otherwise disagree with `git apply`.
-    const lastHunkNoNewline = sortedHunks[0]?.noNewlineAtEndNew ?? false;
-    for (const hunk of sortedHunks) {
-        const newLines = [];
-        // Compute actual old-line count from hunk body for cross-check
-        let actualOldCount = 0;
-        for (const line of hunk.lines) {
-            if (line.startsWith('+')) {
-                newLines.push(line.slice(1));
-            }
-            else if (line.startsWith(' ')) {
-                newLines.push(line.slice(1));
-                actualOldCount++;
-            }
-            else if (line.startsWith('-')) {
-                actualOldCount++;
-            }
-            // Lines starting with '-' are removed (not added to newLines)
-        }
-        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. 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) {
-            if (hunkLine.startsWith(' ') || hunkLine.startsWith('-')) {
-                const expectedContent = hunkLine.slice(1);
-                const actualContent = contentLines[verifyIndex];
-                if (actualContent !== expectedContent) {
-                    throw new PatchError(`Patch context mismatch at line ${verifyIndex + 1} for ${targetFile}: ` +
-                        `expected "${expectedContent}", got "${actualContent}"`, targetFile);
-                }
-                verifyIndex++;
-            }
-        }
-        contentLines.splice(startIndex, hunk.oldCount, ...newLines);
-    }
-    // Respect the no-newline-at-end-of-file marker from the last hunk
-    if (lastHunkNoNewline) {
-        return contentLines.join('\n');
-    }
-    return contentLines.join('\n') + '\n';
-}