@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,312 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
-import { info, warn } from '../utils/logger.js';
-import { discoverPatches, withPatchDirectoryLock } from './patch-apply.js';
-import { findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
-import { addPatchToManifest, loadPatchesManifestForWrite, PATCHES_MANIFEST, savePatchesManifest, } from './patch-manifest.js';
-import { formatPatchOrder, requirePatchOrder } from './patch-parse.js';
-import { allocatePolicyOrder, enforcePatchPolicy } from './patch-policy.js';
-import { manifestWithRetiredSlots, reservationAt, reservedOrderSet } from './patch-retired.js';
-export { findAllPatchesForFiles, findAllPatchesForFilesWithDetails, } from './patch-export-coverage.js';
-import { escapeRegex } from '../utils/regex.js';
-export { mutatePatchMetadata, updatePatchMetadata } from './patch-export-metadata.js';
-export { updatePatchAndMetadata } from './patch-export-update.js';
-/**
- * Projects the planning subset out of a wider export input (commit input,
- * dry-run preview input): the fields `planExport` /
- * `computeExportPlanUnderLock` read. Optional fields are copied only when
- * present so the plan input never carries explicit `undefined` keys, which
- * would otherwise leak into the written metadata via spread. The commit
- * path and the dry-run preview both go through this one projection so
- * they cannot drift field by field.
- */
-export function buildPlanExportInput(input) {
-    return {
-        patchesDir: input.patchesDir,
-        category: input.category,
-        name: input.name,
-        description: input.description,
-        filesAffected: input.filesAffected,
-        sourceEsrVersion: input.sourceEsrVersion,
-        ...(input.sourceProduct !== undefined ? { sourceProduct: input.sourceProduct } : {}),
-        ...(input.sourceVersion !== undefined ? { sourceVersion: input.sourceVersion } : {}),
-        ...(input.tier !== undefined ? { tier: input.tier } : {}),
-        ...(input.lintIgnore !== undefined ? { lintIgnore: input.lintIgnore } : {}),
-        ...(input.config !== undefined ? { config: input.config } : {}),
-    };
-}
-/**
- * Gets the next patch number for a new patch.
- * @param patchesDir - Path to the patches directory
- * @param reserved - Orders held by `patch reserve`, skipped
- * @returns Next patch number (e.g., "005" for 4 existing patches)
- */
-export async function getNextPatchNumber(patchesDir, reserved = new Set()) {
-    const patches = await discoverPatches(patchesDir);
-    const finitePatches = patches.filter((p) => Number.isFinite(p.order));
-    const maxOrder = finitePatches.reduce((max, p) => Math.max(max, p.order), 0);
-    let nextNumber = maxOrder + 1;
-    while (reserved.has(nextNumber))
-        nextNumber++;
-    return String(nextNumber).padStart(Math.max(3, String(nextNumber).length), '0');
-}
-/**
- * Sanitizes a human-readable name into a filename slug.
- *
- * Exported so `patch rename` can produce a filename slug from its
- * `--to <new-name>` argument using the exact same convention `export`
- * uses, without duplicating the lowercase + non-alnum collapse + length
- * cap rules. Drift between the two would let an operator rename a patch
- * to a slug `export` could never reach.
- */
-export function sanitizeName(name) {
-    return name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 50);
-}
-/**
- * Strips a leading `NNN-<category>-` prefix from a sanitized name slug.
- * Operators frequently pass the desired filename stem to `--name`
- * (`--name 203-ui-foo --category ui`), which would otherwise double-prefix
- * into `203-ui-203-ui-foo.patch`. The filename builders prepend the order
- * and category themselves, so a matching prefix in the name is always
- * redundant. Applied repeatedly so a twice-prefixed slug also collapses.
- * Exported for direct testing.
- */
-export function stripRedundantCategoryPrefix(sanitizedName, category) {
-    const prefixes = [
-        new RegExp(`^\\d+-${escapeRegex(category)}-`),
-        new RegExp(`^${escapeRegex(category)}-`),
-    ];
-    let stripped = sanitizedName;
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const prefix of prefixes) {
-            if (prefix.test(stripped)) {
-                stripped = stripped.replace(prefix, '');
-                changed = true;
-            }
-        }
-    }
-    return stripped.length > 0 ? stripped : sanitizedName;
-}
-/**
- * Sanitizes a patch name and drops redundant category/full-stem prefixes.
- *
- * A single trailing `.patch` extension is stripped before sanitisation:
- * operators frequently pass a full patch filename where a name is expected
- * (`move-files <from> 348-ui-foo.patch --create`, `rename --to foo.patch`),
- * and slugging the extension produces double-suffixed `...-patch.patch`
- * files. A name that deliberately ends in a literal `-patch` slug segment
- * must be written without the dot form.
- */
-export function patchNameSlug(name, category) {
-    const stem = name.replace(/\.patch$/i, '');
-    return stripRedundantCategoryPrefix(sanitizeName(stem), category);
-}
-/**
- * Generates the next patch filename with category.
- * @param patchesDir - Path to the patches directory
- * @param category - Patch category
- * @param name - Human-readable name
- * @returns Filename like "001-ui-sidebar.patch"
- */
-export async function getNextPatchFilename(patchesDir, category, name, reserved = new Set()) {
-    const patchNumber = await getNextPatchNumber(patchesDir, reserved);
-    const sanitizedName = patchNameSlug(name, category);
-    return `${patchNumber}-${category}-${sanitizedName}.patch`;
-}
-/**
- * Commits a freshly generated patch file and manifest update under an
- * exclusive patch directory lock so concurrent exports cannot allocate the
- * same number. Shares {@link computeExportPlanUnderLock} with
- * {@link planExport} so the dry-run preview cannot drift from the real
- * write: both paths go through the same planning helper, and any bug fix
- * to filename allocation or supersede detection lands in both automatically.
- */
-export async function commitExportedPatch(input) {
-    return withPatchDirectoryLock(input.patchesDir, async () => {
-        const plan = await computeExportPlanUnderLock(buildPlanExportInput(input));
-        if (input.config !== undefined) {
-            enforcePatchPolicy({
-                config: input.config,
-                manifest: plan.manifestAfter,
-                command: input.policyCommand ?? 'export',
-                forceUnsafe: input.forceUnsafe === true,
-            });
-        }
-        const patchPath = plan.patchPath;
-        const originalPatchContent = (await pathExists(patchPath)) ? await readText(patchPath) : null;
-        const removedPatchContents = new Map();
-        for (const oldPatch of plan.supersededPatches) {
-            if (await pathExists(oldPatch.path)) {
-                removedPatchContents.set(oldPatch.path, await readText(oldPatch.path));
-            }
-        }
-        try {
-            // Patch bodies are written byte-for-byte as git produced them, including the
-            // single-space rendering of a blank context line.
-            //
-            // Do not add a whitespace-trimming pass here or at any other write site.
-            // Stripping marker lines whose payload is pure whitespace (`/^[ +-]\s+$/` →
-            // bare marker) corrupts real content: Firefox sources contain whitespace-only
-            // lines, so a ` `/`-` line whose payload was two spaces no longer matches the
-            // pristine tree and the freshly exported patch fails `git apply --check`,
-            // while a `+` line silently changes what the patch produces. The repository
-            // whitespace check already exempts `patches/*.patch`
-            // (scripts/check-worktree-whitespace.mjs), and the byte-fidelity contract is
-            // pinned end-to-end by `git-diff-latin1-roundtrip.test.ts` and
-            // `re-export.integration.test.ts`.
-            await writeText(patchPath, input.diff);
-            await addPatchToManifest(input.patchesDir, plan.metadata, plan.supersededPatches.map((p) => p.filename));
-            for (const oldPatch of plan.supersededPatches) {
-                await removeFile(oldPatch.path);
-            }
-        }
-        catch (error) {
-            // Best-effort rollback: wrap each operation so a secondary failure
-            // never masks the original failure.
-            try {
-                if (originalPatchContent === null) {
-                    await removeFile(patchPath);
-                }
-                else {
-                    await writeText(patchPath, originalPatchContent);
-                }
-            }
-            catch (error) {
-                warn(`Rollback warning: could not restore patch file: ${toError(error).message}`);
-            }
-            for (const [oldPatchPath, oldPatchContent] of removedPatchContents) {
-                try {
-                    await writeText(oldPatchPath, oldPatchContent);
-                }
-                catch (error) {
-                    warn(`Rollback warning: could not restore ${oldPatchPath}: ${toError(error).message}`);
-                }
-            }
-            try {
-                if (plan.manifestBefore) {
-                    await savePatchesManifest(input.patchesDir, plan.manifestBefore);
-                }
-                else {
-                    await removeFile(join(input.patchesDir, PATCHES_MANIFEST));
-                }
-            }
-            catch (error) {
-                warn(`Rollback warning: could not restore manifest: ${toError(error).message}`);
-            }
-            throw error;
-        }
-        return {
-            patchFilename: plan.patchFilename,
-            metadata: plan.metadata,
-            superseded: plan.supersededPatches,
-        };
-    }, input.lockOptions ?? {});
-}
-/**
- * Updates the content of a patch file.
- * @param patchPath - Path to the patch file
- * @param newContent - New patch content
- */
-export async function updatePatch(patchPath, newContent) {
-    await writeText(patchPath, newContent);
-}
-/**
- * Internal planning helper. It does not take the patch directory lock (the
- * caller must already hold it), because the two public entry points
- * ({@link planExport} and {@link commitExportedPatch}) each take their own
- * lock for the full operation. Sharing this single pure computation is how
- * dry-run previews and real writes stay in lockstep, instead of relying on
- * parallel implementations that can drift.
- */
-async function computeExportPlanUnderLock(input) {
-    // ForWrite: a corrupt manifest read as null here would produce a
-    // manifestAfter containing only the new patch. Committing that plan
-    // wipes the queue metadata, and the rollback path would then delete
-    // patches.json entirely because manifestBefore looked absent.
-    const manifestBefore = await loadPatchesManifestForWrite(input.patchesDir);
-    // A default allocation never lands on a reservation; only an explicit
-    // `--order` placement fills one.
-    const reserved = reservedOrderSet(manifestBefore ?? {});
-    const policyOrder = input.config !== undefined
-        ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category, reserved)
-        : null;
-    const patchFilename = policyOrder !== null
-        ? `${formatPatchOrder(policyOrder)}-${input.category}-${patchNameSlug(input.name, input.category)}.patch`
-        : await getNextPatchFilename(input.patchesDir, input.category, input.name, reserved);
-    const patchPath = join(input.patchesDir, patchFilename);
-    const metadata = {
-        filename: patchFilename,
-        order: requirePatchOrder(patchFilename),
-        category: input.category,
-        name: input.name,
-        description: input.description,
-        createdAt: new Date().toISOString(),
-        sourceEsrVersion: input.sourceEsrVersion,
-        ...(input.sourceProduct !== undefined ? { sourceProduct: input.sourceProduct } : {}),
-        sourceVersion: input.sourceVersion ?? input.sourceEsrVersion,
-        filesAffected: input.filesAffected,
-        ...(input.tier !== undefined ? { tier: input.tier } : {}),
-        ...(input.lintIgnore !== undefined && input.lintIgnore.length > 0
-            ? { lintIgnore: input.lintIgnore }
-            : {}),
-    };
-    const supersedeMatches = await findAllPatchesForFilesWithDetails(input.patchesDir, input.filesAffected, patchFilename);
-    const supersededDetails = supersedeMatches.map((m) => ({
-        filename: m.patch.filename,
-        coveredByFiles: m.coverage.byFiles,
-    }));
-    const supersededPatches = supersedeMatches.map((m) => m.patch);
-    const supersededSet = new Set(supersededDetails.map((s) => s.filename));
-    const afterPatches = (manifestBefore?.patches ?? []).filter((p) => !supersededSet.has(p.filename) && p.filename !== patchFilename);
-    afterPatches.push(metadata);
-    afterPatches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    const reservation = reservationAt(manifestBefore, metadata.order);
-    if (reservation !== undefined) {
-        info(`Order ${formatPatchOrder(metadata.order)} was reserved by ${reservation.owner}` +
-            `${reservation.reason !== undefined ? ` (${reservation.reason})` : ''}; ` +
-            'this export fills the reservation.');
-    }
-    return {
-        patchFilename,
-        patchPath,
-        metadata,
-        supersededDetails,
-        supersededPatches,
-        manifestBefore: manifestBefore ?? null,
-        // A patch landing on a retired or reserved order fills that slot.
-        manifestAfter: manifestWithRetiredSlots(manifestBefore, afterPatches),
-    };
-}
-/**
- * Read-only planning function. Computes everything a real export would
- * do without writing anything to disk. Takes the patch directory lock
- * briefly, runs {@link computeExportPlanUnderLock}, releases the lock,
- * and returns the plan for preview rendering.
- *
- * Shares {@link computeExportPlanUnderLock} with {@link commitExportedPatch}
- * so the dry-run preview cannot drift from the real write. The real write
- * path does not reuse a prior plan object (another export may have landed
- * between dry-run and commit, which would stale the filename allocation).
- * It re-runs the same helper under a fresh lock. The guarantee is "same
- * code, possibly different data," not "same plan object."
- */
-export async function planExport(input) {
-    return withPatchDirectoryLock(input.patchesDir, async () => {
-        const plan = await computeExportPlanUnderLock(input);
-        return {
-            patchFilename: plan.patchFilename,
-            metadata: plan.metadata,
-            superseded: plan.supersededDetails,
-            manifestBefore: plan.manifestBefore,
-            manifestAfter: plan.manifestAfter,
-        };
-    });
-}

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

@@ -1,17 +0,0 @@
-import type { PatchInfo } from '../types/commands/index.js';
-/** Discovers patch files in a directory and returns them in apply order. */
-export declare function discoverPatches(patchesDir: string): Promise<PatchInfo[]>;
-/** Counts the patch files currently present in a patch directory. */
-export declare function countPatches(patchesDir: string): Promise<number>;
-/**
- * Returns all target file paths referenced by a multi-file patch.
- *
- * Delegates to {@link extractAffectedFiles} so `GIT binary patch` sections
- * (which have no `+++ b/…` line, only a `diff --git a/… b/…` header) are
- * included alongside text hunks. Matching only `+++ b/…` lines drops every
- * binary file from `filesAffected`, so verify reports
- * `files-affected-mismatch` against branding patches and
- * `doctor --repair-patches-manifest` "repairs" the manifest by rewriting it
- * to the text-only subset, hiding the true scope of the patch.
- */
-export declare function getAllTargetFilesFromPatch(patchPath: string): Promise<string[]>;

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

@@ -1,59 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir, stat } from 'node:fs/promises';
-import { extname, join } from 'node:path';
-import { pathExists, readText } from '../utils/fs.js';
-import { extractAffectedFiles, extractOrder } from './patch-parse.js';
-/** Discovers patch files in a directory and returns them in apply order. */
-export async function discoverPatches(patchesDir) {
-    if (!(await pathExists(patchesDir))) {
-        return [];
-    }
-    const entries = await readdir(patchesDir, { withFileTypes: true });
-    const patches = [];
-    for (const entry of entries) {
-        if (extname(entry.name) !== '.patch')
-            continue;
-        // A symlinked patch (a scratch queue built from links to the real
-        // patches) counts when it resolves to a regular file; a dangling link or
-        // a link to a directory does not.
-        if (!entry.isFile() &&
-            !(entry.isSymbolicLink() && (await isLinkToFile(patchesDir, entry.name)))) {
-            continue;
-        }
-        patches.push({
-            path: join(patchesDir, entry.name),
-            filename: entry.name,
-            order: extractOrder(entry.name),
-        });
-    }
-    patches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    return patches;
-}
-async function isLinkToFile(dir, name) {
-    try {
-        return (await stat(join(dir, name))).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-/** Counts the patch files currently present in a patch directory. */
-export async function countPatches(patchesDir) {
-    const patches = await discoverPatches(patchesDir);
-    return patches.length;
-}
-/**
- * Returns all target file paths referenced by a multi-file patch.
- *
- * Delegates to {@link extractAffectedFiles} so `GIT binary patch` sections
- * (which have no `+++ b/…` line, only a `diff --git a/… b/…` header) are
- * included alongside text hunks. Matching only `+++ b/…` lines drops every
- * binary file from `filesAffected`, so verify reports
- * `files-affected-mismatch` against branding patches and
- * `doctor --repair-patches-manifest` "repairs" the manifest by rewriting it
- * to the text-only subset, hiding the true scope of the patch.
- */
-export async function getAllTargetFilesFromPatch(patchPath) {
-    const content = await readText(patchPath);
-    return extractAffectedFiles(content);
-}

package/dist/src/core/patch-identifier-suggest.d.ts

@@ -1,26 +0,0 @@
-/**
- * Builds a concise "patch not found" error message with did-you-mean
- * suggestions in place of the full queue enumeration.
- *
- * Joining every queued patch's filename and manifest name into a
- * comma-separated `Available: ...` tail runs ~1500 characters on a 29-patch
- * queue and buries the actual error. This ranks each known identifier
- * (ordinal, filename with and without `.patch`, manifest name) by
- * Levenshtein distance from the operator's input, surfaces up to three
- * plausible suggestions, and falls back to a count-only summary pointing at
- * `fireforge patch list` when no close match exists.
- */
-import type { PatchMetadata } from '../types/commands/index.js';
-/**
- * Formats the user-facing "patch not found" error message used by
- * `patch delete`, `patch reorder`, `patch tier`, and
- * `patch lint-ignore`. Returns a single string suitable for the
- * `InvalidArgumentError` body, never the full queue enumeration.
- */
-export declare function formatPatchNotFoundError(identifier: string, patches: readonly PatchMetadata[]): string;
-/**
- * The nearest-match half of {@link formatPatchNotFoundError}: the closest
- * accepted identifiers and the queue size, never the full queue. For
- * callers that word their own lead, such as the `--patches` subset.
- */
-export declare function formatPatchSuggestions(identifier: string, patches: readonly PatchMetadata[]): string;

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

@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Builds a concise "patch not found" error message with did-you-mean
- * suggestions in place of the full queue enumeration.
- *
- * Joining every queued patch's filename and manifest name into a
- * comma-separated `Available: ...` tail runs ~1500 characters on a 29-patch
- * queue and buries the actual error. This ranks each known identifier
- * (ordinal, filename with and without `.patch`, manifest name) by
- * Levenshtein distance from the operator's input, surfaces up to three
- * plausible suggestions, and falls back to a count-only summary pointing at
- * `fireforge patch list` when no close match exists.
- */
-/** Maximum Levenshtein distance accepted as a "did you mean" suggestion. */
-const SUGGESTION_DISTANCE_THRESHOLD = 3;
-/**
- * Shortest side accepted for a prefix relation. Below this a prefix match
- * is noise: a one-character ordinal prefixes almost anything.
- */
-const MIN_PREFIX_MATCH_LENGTH = 4;
-/** Maximum number of suggestions to surface in the error message. */
-const SUGGESTION_LIMIT = 3;
-/**
- * Computes the Levenshtein edit distance between two strings. Used by
- * `formatPatchNotFoundError` to rank candidate identifiers. The small
- * upper bound on input lengths (filenames, ordinals, names) makes the
- * O(m*n) implementation trivially fast.
- */
-function levenshtein(a, b) {
-    if (a === b)
-        return 0;
-    if (a.length === 0)
-        return b.length;
-    if (b.length === 0)
-        return a.length;
-    // Allocate the row buffers up-front and fill with zero so every index in
-    // [0, b.length] is populated before any read. Using `Array.fill(0)` keeps
-    // the type as `number[]` (not `(number | undefined)[]`) so subsequent
-    // index reads compose without optional-chaining noise.
-    const prev = new Array(b.length + 1).fill(0);
-    const curr = new Array(b.length + 1).fill(0);
-    for (let j = 0; j <= b.length; j++)
-        prev[j] = j;
-    for (let i = 1; i <= a.length; i++) {
-        curr[0] = i;
-        for (let j = 1; j <= b.length; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            const left = curr[j - 1] ?? 0;
-            const up = prev[j] ?? 0;
-            const diag = prev[j - 1] ?? 0;
-            curr[j] = Math.min(left + 1, up + 1, diag + cost);
-        }
-        for (let j = 0; j <= b.length; j++)
-            prev[j] = curr[j] ?? 0;
-    }
-    return prev[b.length] ?? 0;
-}
-/**
- * Collects every identifier shape FireForge accepts for a queue entry:
- *   - the ordinal (string form), e.g. `"2"`
- *   - the filename, e.g. `"002-ui-foo.patch"`
- *   - the filename without the `.patch` suffix, e.g. `"002-ui-foo"`
- *   - the manifest `name` field, when distinct from the filename
- * Returned as a flat list so the suggestion ranking can compare each
- * candidate independently.
- */
-function collectAcceptedIdentifiers(patches) {
-    const set = new Set();
-    for (const patch of patches) {
-        set.add(String(patch.order));
-        set.add(patch.filename);
-        if (patch.filename.endsWith('.patch')) {
-            set.add(patch.filename.slice(0, -'.patch'.length));
-        }
-        if (patch.name && patch.name !== patch.filename)
-            set.add(patch.name);
-    }
-    return Array.from(set);
-}
-/**
- * Returns up to {@link SUGGESTION_LIMIT} accepted identifiers ordered
- * by closest Levenshtein distance to {@link identifier}, dropping any
- * candidate whose distance exceeds {@link SUGGESTION_DISTANCE_THRESHOLD}.
- */
-function rankSuggestions(identifier, candidates) {
-    const needle = identifier.toLowerCase();
-    return candidates
-        .map((candidate) => {
-        const lower = candidate.toLowerCase();
-        // Prefix relation in either direction is a stronger signal than edit
-        // distance and is not bounded by it: a partial ordinal or an
-        // abbreviated slug ("ui-foo" for "002-ui-foo.patch") is many edits away
-        // from the full identifier yet is obviously the intended target.
-        // `lower.startsWith(needle)`: the operator typed an abbreviation of a
-        // real identifier. The reverse relation is only meaningful when the
-        // candidate is substantial. Otherwise the single-character ordinal
-        // "9" would "match" every input starting with a 9.
-        const prefixMatch = needle.length >= MIN_PREFIX_MATCH_LENGTH &&
-            (lower.startsWith(needle) ||
-                (lower.length >= MIN_PREFIX_MATCH_LENGTH && needle.startsWith(lower)));
-        return {
-            candidate,
-            prefixMatch,
-            distance: levenshtein(identifier, candidate),
-        };
-    })
-        .filter((entry) => entry.prefixMatch || entry.distance <= SUGGESTION_DISTANCE_THRESHOLD)
-        .sort((a, b) => Number(b.prefixMatch) - Number(a.prefixMatch) ||
-        a.distance - b.distance ||
-        a.candidate.localeCompare(b.candidate))
-        .slice(0, SUGGESTION_LIMIT)
-        .map((entry) => entry.candidate);
-}
-/**
- * Formats the user-facing "patch not found" error message used by
- * `patch delete`, `patch reorder`, `patch tier`, and
- * `patch lint-ignore`. Returns a single string suitable for the
- * `InvalidArgumentError` body, never the full queue enumeration.
- */
-export function formatPatchNotFoundError(identifier, patches) {
-    const lead = `Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo).`;
-    return `${lead} ${formatPatchSuggestions(identifier, patches)}`;
-}
-/**
- * The nearest-match half of {@link formatPatchNotFoundError}: the closest
- * accepted identifiers and the queue size, never the full queue. For
- * callers that word their own lead, such as the `--patches` subset.
- */
-export function formatPatchSuggestions(identifier, patches) {
-    const suggestions = rankSuggestions(identifier, collectAcceptedIdentifiers(patches));
-    if (suggestions.length > 0) {
-        return `Did you mean: ${suggestions.join(', ')}? (${patches.length} patches in queue — run "fireforge patch list" for the full list.)`;
-    }
-    return `No close match found among ${patches.length} patches in the queue. Run "fireforge patch list" to see them.`;
-}

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

@@ -1,45 +0,0 @@
-/**
- * Queue-wide lint for binary patch bodies that cannot recreate their file.
- *
- * `git diff` has two ways to render a binary change. `git diff --binary`
- * emits a `GIT binary patch` section carrying the literal/delta payload,
- * and that body can be replayed by `git apply`. Plain `git diff` emits only
- * the informational `Binary files a/x and b/x differ`, which records that
- * the bytes changed and carries none of them.
- *
- * The stub form is dangerous rather than merely lossy because it still
- * carries a correct `index <old>..<new>` line. Every identity-shaped check in
- * the codebase (worktree classification, foreign-drift detection) keys on
- * that hash, matches it against the live file, and concludes the patch is
- * backed. So a queue can hold a patch that provably cannot rebuild its own
- * file while every gate reports green, and the loss surfaces only at the next
- * clean-room apply. This rule is the one check that reads the body itself and
- * fails closed, whichever command wrote it.
- *
- * Body-only: it needs no engine checkout, so it runs anywhere the
- * queue context is available and never pulls an engine dependency into the
- * cross-patch lint graph.
- */
-import type { PatchLintIssue } from '../types/commands/index.js';
-import type { PatchQueueBodyEntry, PatchQueueView } from './patch-lint-queue-types.js';
-/**
- * Queue view accepted by {@link lintPatchQueueBinaryBodies}. Described
- * structurally rather than by importing `PatchQueueContext` from
- * `patch-lint-cross.ts`, which imports this module back. The shared leaf
- * type keeps the dependency edge one-way and `dpdm` clean.
- */
-type BinaryBodyQueueContext = PatchQueueView<PatchQueueBodyEntry>;
-/** Lint check identifier emitted by {@link lintPatchQueueBinaryBodies}. */
-export declare const BINARY_BODY_CHECK = "binary-body-not-reconstructable";
-/**
- * Flags every binary diff section whose body carries no reconstructable
- * payload.
- *
- * Deletions are exempt: a `deleted file mode` section needs no bytes to
- * replay, so the informational form is complete for that case.
- *
- * @param ctx - Queue context (raw patch bodies in application order)
- * @returns One error-severity issue per offending file per patch
- */
-export declare function lintPatchQueueBinaryBodies(ctx: BinaryBodyQueueContext): PatchLintIssue[];
-export {};

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

@@ -1,39 +0,0 @@
-import { parseDiffSections } from './patch-parse.js';
-/** Lint check identifier emitted by {@link lintPatchQueueBinaryBodies}. */
-export const BINARY_BODY_CHECK = 'binary-body-not-reconstructable';
-/**
- * Flags every binary diff section whose body carries no reconstructable
- * payload.
- *
- * Deletions are exempt: a `deleted file mode` section needs no bytes to
- * replay, so the informational form is complete for that case.
- *
- * @param ctx - Queue context (raw patch bodies in application order)
- * @returns One error-severity issue per offending file per patch
- */
-export function lintPatchQueueBinaryBodies(ctx) {
-    const issues = [];
-    for (const entry of ctx.entries) {
-        const seen = new Set();
-        for (const section of parseDiffSections(entry.diff)) {
-            if (!section.isBinary || section.hasBinaryDelta || section.isDeletedFile)
-                continue;
-            const file = section.targetPath;
-            if (seen.has(file))
-                continue;
-            seen.add(file);
-            issues.push({
-                file,
-                check: BINARY_BODY_CHECK,
-                patches: [entry.filename],
-                fingerprint: `${BINARY_BODY_CHECK}|${entry.filename}|${file}`,
-                message: `Binary file "${file}" is recorded in ${entry.filename} as "Binary files … differ", ` +
-                    'which carries no data and cannot recreate the file on apply. ' +
-                    `Re-export the patch from a tree where ${file} is present ` +
-                    `("fireforge re-export ${entry.filename}") so the body carries a GIT binary patch delta.`,
-                severity: 'error',
-            });
-        }
-    }
-    return issues;
-}