@hominis/fireforge 0.54.0 → 0.60.0

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

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Signal-deferred critical sections.
- *
- * Commands that perform a compound mutation (e.g. "apply a patch to the
- * engine, then persist progress to a session file on disk") need to finish
- * the pair atomically with respect to SIGINT / SIGTERM. The furnace rollback
- * mechanism is not the right tool here: rebase-style operations intentionally
- * leave the engine mutated and only need the on-disk bookkeeping write to
- * complete before the process exits.
- *
- * `runInSignalCriticalSection(fn)` wraps a short body in a registry slot.
- * While the body runs, the CLI entry point's SIGINT / SIGTERM handlers wait
- * for the slot to clear before calling `process.exit`, so a signal that
- * lands mid-body is held until the body's state write finishes.
- *
- * This module is a pure runtime registry. It installs no signal handlers
- * itself. The bin entry point is responsible for awaiting
- * `waitForActiveCriticalSections` before terminating.
- */
-import { sleep } from '../utils/sleep.js';
-const activeSections = new Set();
-/**
- * Runs `fn` inside a signal-deferred critical section. The CLI entry point's
- * signal handlers `await` every active section before exiting, so a SIGINT or
- * SIGTERM that arrives during `fn` will hold exit until `fn` returns (or
- * rejects).
- *
- * `fn` should be short. Anything that takes longer than the bounded wait in
- * the bin handler (`SIGNAL_CRITICAL_SECTION_TIMEOUT_MS`) will time out and
- * the handler will exit anyway. The intent is "guard the apply + state
- * persist pair," not "postpone exit indefinitely."
- */
-export async function runInSignalCriticalSection(label, fn) {
-    let resolver = () => undefined;
-    const section = {
-        label,
-        promise: new Promise((resolve) => {
-            resolver = resolve;
-        }),
-    };
-    activeSections.add(section);
-    try {
-        return await fn();
-    }
-    finally {
-        activeSections.delete(section);
-        resolver();
-    }
-}
-/**
- * Waits for every active critical section to complete or for `timeoutMs` to
- * elapse, whichever comes first. Never rejects: a section that throws still
- * resolves from the registry's perspective because `runInSignalCriticalSection`
- * cleans up in `finally`.
- */
-export async function waitForActiveCriticalSections(timeoutMs) {
-    if (activeSections.size === 0)
-        return;
-    const snapshot = [...activeSections].map((s) => s.promise);
-    await Promise.race([Promise.allSettled(snapshot).then(() => undefined), sleep(timeoutMs)]);
-}

package/dist/src/core/smoke-patterns.d.ts

@@ -1,81 +0,0 @@
-/**
- * Shared regex library for `fireforge run --smoke-exit`. Used by the smoke
- * runner to decide whether a console line from the real chrome counts as a
- * runtime error. Kept separate from the runner so the patterns can be
- * exercised in isolation and amended without touching process-group logic.
- *
- * Matching is anchored at the start of the line (`^`) on purpose: a runtime
- * error leaves a canonical prefix that Firefox's logging layer prints at
- * column zero. Embedded mentions of the same string inside an unrelated
- * warning (e.g. `"pending JavaScript error cleanup"`) do not start with
- * the prefix and should not trip the scanner.
- */
-/**
- * Returns `true` when `line` matches any pattern in
- * {@link SMOKE_ERROR_PATTERNS}. Does not consult the allowlist. That step
- * lives in {@link matchAllowlist}, so the smoke runner can count
- * allowlisted hits separately from raw error matches for its summary.
- */
-export declare function matchesSmokeError(line: string): boolean;
-/**
- * Returns `true` when `line` is console output from the browser rather than
- * mach's own timestamped log. A blank line is neither.
- */
-export declare function isBrowserConsoleLine(line: string): boolean;
-/**
- * One compiled allowlist entry with its provenance retained so the smoke
- * summary can attribute hits per entry. An entry that silently
- * stops matching (its suppressed shape changed upstream) is only
- * detectable when zero-hit entries are visible.
- */
-export interface CompiledAllowlistEntry {
-    pattern: RegExp;
-    /** Verbatim source text of the entry. */
-    source: string;
-    /** Human-readable origin: `allow.txt:12` or `--console-allow #2`. */
-    origin: string;
-    /**
-     * Ceiling from a `# max-hits: N` directive above the entry: how often the
-     * suppressed cause can physically fire in one boot. More hits than this
-     * is a flood wearing an allowlisted shape, and fails the run.
-     */
-    maxHits?: number;
-}
-/**
- * Returns the index of the FIRST entry in `allow` matching `line`, or -1.
- * First-match attribution is deterministic and cheap. A line matching
- * several entries credits the earliest one. Safe to call with an empty
- * allowlist (always returns -1).
- */
-export declare function matchAllowlist(line: string, allow: readonly CompiledAllowlistEntry[]): number;
-/**
- * Parses a newline-delimited allowlist file body. Lines are trimmed. Blank
- * lines and `#`-prefixed comments are skipped. Each remaining line is
- * compiled as a RegExp with its `<file>:<line>` origin retained. A bad
- * pattern throws immediately: better to fail fast at CLI parse time than
- * to silently let a typo match nothing.
- *
- * A `# max-hits: N` comment sets the ceiling of the entry that follows it
- * (other comment lines may sit between). A blank line or end of file with
- * no entry after the directive is an error rather than a silently dropped
- * cap, since a cap the operator wrote and the run ignored is the exact
- * shape of failure this directive exists to prevent.
- */
-export declare function compileAllowlistFromFile(body: string, sourcePath: string): CompiledAllowlistEntry[];
-/** An allowlist entry that matched more lines than its `# max-hits` ceiling. */
-export interface OverCapAllowlistEntry {
-    entry: CompiledAllowlistEntry;
-    hits: number;
-    maxHits: number;
-}
-/**
- * Entries whose per-entry hit count (every matched line, error-class or
- * not: the `N×` number the attribution block prints and the operator tunes
- * against) exceeds their ceiling. Entries without a ceiling never appear.
- */
-export declare function findOverCapAllowlistEntries(allow: readonly CompiledAllowlistEntry[], hits: readonly number[]): OverCapAllowlistEntry[];
-/**
- * Compiles an array of regex-string inputs (e.g. repeated `--console-allow`
- * flag values). Same fail-fast semantics as {@link compileAllowlistFromFile}.
- */
-export declare function compileAllowlistFromStrings(sources: readonly string[]): CompiledAllowlistEntry[];

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

@@ -1,176 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Shared regex library for `fireforge run --smoke-exit`. Used by the smoke
- * runner to decide whether a console line from the real chrome counts as a
- * runtime error. Kept separate from the runner so the patterns can be
- * exercised in isolation and amended without touching process-group logic.
- *
- * Matching is anchored at the start of the line (`^`) on purpose: a runtime
- * error leaves a canonical prefix that Firefox's logging layer prints at
- * column zero. Embedded mentions of the same string inside an unrelated
- * warning (e.g. `"pending JavaScript error cleanup"`) do not start with
- * the prefix and should not trip the scanner.
- */
-/**
- * Line prefixes that signal an actual runtime error in a Firefox chrome
- * process. A hit on any of these patterns is a smoke failure unless the
- * line also matches the caller-supplied allowlist.
- *
- * Additions here should be conservative. False positives turn every
- * smoke run into noise for operators and every CI run into flake.
- */
-import { toError } from '../utils/errors.js';
-const SMOKE_ERROR_PATTERNS = [
-    // Firefox chrome error lines: `JavaScript error: chrome://…, line N: TypeError: …`.
-    /^\s*JavaScript error:/i,
-    // Some log paths prefix browser-console `console.error(...)` with the literal label below.
-    /^\s*console\.error:/i,
-    // Older bracketed-prefix variant still seen in some chrome logs / test runs.
-    /^\s*\[JavaScript (Error|Warning)\]/i,
-    // IPC-layer fatal assertions. Firefox prints `###!!! [Parent] Error: …` on content-process crashes.
-    /^\s*###!!! \[Parent\]/,
-    // A chrome:// or resource:// URL that resolves to nothing. Outside
-    // automation Gecko only PRINTS this (printf_stderr in
-    // `CheckForBrokenChromeURL`, netwerk/base/nsNetUtil.cpp). Under
-    // `xpc::IsInAutomation()` the same condition is a
-    // `MOZ_CRASH_UNSAFE_PRINTF` in whichever process opened the channel. So
-    // the smoke probe, which runs outside automation, sees the printed
-    // line for the same defect that hard-crashes every harness run, and a
-    // probe that exits 0 on it reports "startup is healthy" for a build that
-    // hangs at "Waiting for browser…". Both spellings are matched: the
-    // non-automation singular `URL:` and the automation plural `URLs:`.
-    // Allowlistable through `--console-allow` like any other pattern.
-    /^\s*Missing chrome or resource URLs?:/,
-];
-/**
- * Returns `true` when `line` matches any pattern in
- * {@link SMOKE_ERROR_PATTERNS}. Does not consult the allowlist. That step
- * lives in {@link matchAllowlist}, so the smoke runner can count
- * allowlisted hits separately from raw error matches for its summary.
- */
-export function matchesSmokeError(line) {
-    for (const pattern of SMOKE_ERROR_PATTERNS) {
-        if (pattern.test(line)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Mach's own log lines carry an elapsed-time prefix (` 0:00.42 <message>`),
- * the first of which echoes the browser command line. They prove mach ran,
- * not that the browser printed anything.
- */
-const MACH_LOG_LINE = /^\s*\d+:\d{2}\.\d{2} /;
-/**
- * Returns `true` when `line` is console output from the browser rather than
- * mach's own timestamped log. A blank line is neither.
- */
-export function isBrowserConsoleLine(line) {
-    return line.trim() !== '' && !MACH_LOG_LINE.test(line);
-}
-/** `# max-hits: N` on its own comment line, case-insensitive. */
-const MAX_HITS_DIRECTIVE = /^#\s*max-hits:\s*(\S+)\s*$/i;
-function parseMaxHitsDirective(raw, at) {
-    if (!/^[1-9]\d*$/.test(raw)) {
-        throw new Error(`Invalid allowlist max-hits directive at ${at}: expected a positive integer (got "${raw}")`);
-    }
-    return Number.parseInt(raw, 10);
-}
-/**
- * Returns the index of the FIRST entry in `allow` matching `line`, or -1.
- * First-match attribution is deterministic and cheap. A line matching
- * several entries credits the earliest one. Safe to call with an empty
- * allowlist (always returns -1).
- */
-export function matchAllowlist(line, allow) {
-    return allow.findIndex((entry) => entry.pattern.test(line));
-}
-/**
- * Parses a newline-delimited allowlist file body. Lines are trimmed. Blank
- * lines and `#`-prefixed comments are skipped. Each remaining line is
- * compiled as a RegExp with its `<file>:<line>` origin retained. A bad
- * pattern throws immediately: better to fail fast at CLI parse time than
- * to silently let a typo match nothing.
- *
- * A `# max-hits: N` comment sets the ceiling of the entry that follows it
- * (other comment lines may sit between). A blank line or end of file with
- * no entry after the directive is an error rather than a silently dropped
- * cap, since a cap the operator wrote and the run ignored is the exact
- * shape of failure this directive exists to prevent.
- */
-export function compileAllowlistFromFile(body, sourcePath) {
-    const lines = body.split(/\r?\n/);
-    const compiled = [];
-    let pending;
-    const assertNoOrphanDirective = () => {
-        if (pending) {
-            throw new Error(`Invalid allowlist max-hits directive at ${pending.at}: no entry follows it (the ceiling applies to the next non-comment line)`);
-        }
-    };
-    lines.forEach((raw, index) => {
-        const line = raw.trim();
-        const at = `${sourcePath}:${index + 1}`;
-        if (!line) {
-            assertNoOrphanDirective();
-            return;
-        }
-        if (line.startsWith('#')) {
-            const directive = MAX_HITS_DIRECTIVE.exec(line);
-            if (directive)
-                pending = { maxHits: parseMaxHitsDirective(directive[1] ?? '', at), at };
-            return;
-        }
-        try {
-            compiled.push({
-                pattern: new RegExp(line),
-                source: line,
-                origin: at,
-                ...(pending ? { maxHits: pending.maxHits } : {}),
-            });
-        }
-        catch (error) {
-            const message = toError(error).message;
-            throw new Error(`Invalid allowlist regex at ${at}: ${message}`, { cause: error });
-        }
-        pending = undefined;
-    });
-    assertNoOrphanDirective();
-    return compiled;
-}
-/**
- * Entries whose per-entry hit count (every matched line, error-class or
- * not: the `N×` number the attribution block prints and the operator tunes
- * against) exceeds their ceiling. Entries without a ceiling never appear.
- */
-export function findOverCapAllowlistEntries(allow, hits) {
-    const over = [];
-    allow.forEach((entry, index) => {
-        const count = hits[index] ?? 0;
-        if (entry.maxHits !== undefined && count > entry.maxHits) {
-            over.push({ entry, hits: count, maxHits: entry.maxHits });
-        }
-    });
-    return over;
-}
-/**
- * Compiles an array of regex-string inputs (e.g. repeated `--console-allow`
- * flag values). Same fail-fast semantics as {@link compileAllowlistFromFile}.
- */
-export function compileAllowlistFromStrings(sources) {
-    const compiled = [];
-    sources.forEach((source, index) => {
-        try {
-            compiled.push({
-                pattern: new RegExp(source),
-                source,
-                origin: `--console-allow #${index + 1}`,
-            });
-        }
-        catch (error) {
-            const message = toError(error).message;
-            throw new Error(`Invalid --console-allow regex at position ${index + 1} ("${source}"): ${message}`, { cause: error });
-        }
-    });
-    return compiled;
-}

package/dist/src/core/state-file.d.ts

@@ -1,60 +0,0 @@
-/** Runs an operation while holding the sidecar lock for a FireForge state file. */
-export declare function withStateFileLock<T>(statePath: string, operation: () => Promise<T>): Promise<T>;
-/**
- * A filesystem-safe, sortable timestamp: `2026-08-28T14-32-05-123Z`.
- *
- * Colons are not portable in filenames (Windows rejects them outright), so
- * the ISO form is punctuated with dashes only. Lexical order still equals
- * chronological order, which is what run-log pruning relies on.
- *
- * @param now - Instant to render
- * @returns The ISO-8601 form with `:` and `.` replaced by `-`
- */
-export declare function fileSafeTimestamp(now: Date): string;
-/** Renames a state file out of the way while preserving it for later inspection. */
-export declare function quarantineStateFile(statePath: string, reason?: string): Promise<string | undefined>;
-/**
- * Outcome of a version check on a persisted FireForge document.
- *
- * The distinction that matters is `newer` vs `corrupt`. A document written
- * by a newer FireForge is not damaged. The operator simply needs to upgrade.
- * A check that collapses the two offers destructive remedies. The
- * sharpest case is the tree marker, whose `schemaVersion` check inside a
- * boolean type guard makes a `schemaVersion: 2` marker read as "missing or
- * mistypes a required field". `tree-guard.ts` is default-deny on corrupt, so
- * a newer FireForge would lock the operator out of every mutating command
- * inside that tree.
- *
- * `furnace.json` is the pattern the rest should follow: it refuses a newer
- * version by name and tells the operator to upgrade (`validateConfigVersion`
- * in `furnace-config.ts`).
- */
-export type DocumentVersionCheck = {
-    kind: 'current';
-} | {
-    kind: 'older';
-    found: number;
-} | {
-    kind: 'newer';
-    found: number;
-} | {
-    kind: 'malformed';
-};
-/**
- * Classifies a persisted document's `version`/`schemaVersion` field.
- *
- * @param raw - The parsed document
- * @param field - Version field name, e.g. `schemaVersion`
- * @param supported - Version this build writes and understands
- * @returns Whether the document is current, older, newer, or malformed
- */
-export declare function checkDocumentVersion(raw: unknown, field: string, supported: number): DocumentVersionCheck;
-/**
- * The refusal shown for a document this build is too old to read.
- *
- * @param label - Operator-facing document name, e.g. `tree marker`
- * @param found - Version found on disk
- * @param supported - Version this build understands
- * @returns A message naming both versions and the remedy
- */
-export declare function describeNewerDocument(label: string, found: number, supported: number): string;

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

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { rename } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { pathExists } from '../utils/fs.js';
-import { createSiblingLockPath, withFileLock } from './file-lock.js';
-/** Runs an operation while holding the sidecar lock for a FireForge state file. */
-export async function withStateFileLock(statePath, operation) {
-    return withFileLock(createSiblingLockPath(statePath, '.fireforge-state.lock'), operation, {
-        onTimeoutMessage: `Timed out waiting to update FireForge state at ${statePath}. ` +
-            'If no other fireforge process is running, remove the stale lock directory and retry.',
-        onStaleLockMessage: (ageMs) => `Removing stale FireForge state lock for ${basename(statePath)} ` +
-            `(age: ${Math.round(ageMs / 1000)}s). A previous fireforge process may have crashed.`,
-    });
-}
-/**
- * A filesystem-safe, sortable timestamp: `2026-08-28T14-32-05-123Z`.
- *
- * Colons are not portable in filenames (Windows rejects them outright), so
- * the ISO form is punctuated with dashes only. Lexical order still equals
- * chronological order, which is what run-log pruning relies on.
- *
- * @param now - Instant to render
- * @returns The ISO-8601 form with `:` and `.` replaced by `-`
- */
-export function fileSafeTimestamp(now) {
-    return now.toISOString().replace(/[:.]/g, '-');
-}
-/** Renames a state file out of the way while preserving it for later inspection. */
-export async function quarantineStateFile(statePath, reason = 'corrupt') {
-    if (!(await pathExists(statePath))) {
-        return undefined;
-    }
-    const timestamp = fileSafeTimestamp(new Date());
-    const quarantinedPath = `${statePath}.${reason}-${timestamp}`;
-    await rename(statePath, quarantinedPath);
-    return basename(quarantinedPath);
-}
-/**
- * Classifies a persisted document's `version`/`schemaVersion` field.
- *
- * @param raw - The parsed document
- * @param field - Version field name, e.g. `schemaVersion`
- * @param supported - Version this build writes and understands
- * @returns Whether the document is current, older, newer, or malformed
- */
-export function checkDocumentVersion(raw, field, supported) {
-    if (typeof raw !== 'object' || raw === null)
-        return { kind: 'malformed' };
-    const found = raw[field];
-    if (typeof found !== 'number' || !Number.isInteger(found) || found < 1) {
-        return { kind: 'malformed' };
-    }
-    if (found > supported)
-        return { kind: 'newer', found };
-    if (found < supported)
-        return { kind: 'older', found };
-    return { kind: 'current' };
-}
-/**
- * The refusal shown for a document this build is too old to read.
- *
- * @param label - Operator-facing document name, e.g. `tree marker`
- * @param found - Version found on disk
- * @param supported - Version this build understands
- * @returns A message naming both versions and the remedy
- */
-export function describeNewerDocument(label, found, supported) {
-    return (`the ${label} was written by a newer FireForge (schema version ${found}; ` +
-        `this build understands ${supported}). Upgrade FireForge to read it — the file is ` +
-        'not damaged, so do not delete it.');
-}

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

@@ -1,62 +0,0 @@
-/**
- * Binary-aware drift classification for patch-owned files.
- *
- * The text classifier compares utf-8 decoded content against
- * `computePatchedContent`, which cannot apply `GIT binary patch` bodies, so
- * a binary file exported into a patch classifies as `patch-owned-drift`
- * forever, keeping the engine-clean gate permanently red with nothing
- * actually un-durable. A `GIT binary patch` section does carry the ground
- * truth: `git diff --binary` always records full blob hashes on the section's
- * `index <old>..<new>` line. Comparing the live file's `git hash-object`
- * against the last owning section's new-side hash settles the classification
- * exactly. Bodies without a usable hash (hand-written diffs) classify as
- * `binary-unsupported`: an honest "cannot compare" instead of a false "not
- * durable".
- *
- * That hash is trusted only when the section carries a replayable payload
- * (`hasBinaryDelta`). A `Binary files … differ` stub carries a correct index
- * line too, so hashing against it reports `patch-backed` for a body that
- * cannot rebuild the file at all, which is the dishonesty this module
- * exists to avoid. Such a body is `binary-unsupported` here, and an error
- * from the `binary-body-not-reconstructable` queue lint.
- *
- * Lives in its own module (not `status-classify.ts`) so the classifier stays
- * within the per-file line budget and this module never has to import it
- * back: the dependency edge points one way, which keeps dpdm clean.
- */
-import type { PatchedContentContext } from './patch-apply.js';
-/** Batched patch lookup, injected by callers that classify many files. */
-export type AffectingPatchLookup = Pick<PatchedContentContext, 'getAffectingPatches' | 'readPatchBody'> & Partial<Pick<PatchedContentContext, 'liveBlobHash'>>;
-/**
- * Classification result for a binary comparison. Structurally assignable
- * to `ClassifiedFile` without importing it (which would create a cycle
- * with `status-classify.ts`).
- */
-export interface BinaryClassifiedFile {
-    status: string;
-    file: string;
-    classification: 'patch-backed' | 'furnace' | 'patch-owned-drift' | 'binary-unsupported';
-    owner: string;
-}
-/**
- * Classifies a single-owner file whose comparison is binary. Returns
- * `null` when the comparison is not binary (the live file is text and,
- * for deletions, the owning section is text), so the caller falls
- * through to the existing utf-8 content comparison unchanged.
- *
- * @param args.fileMissing - True when the porcelain status reports the
- *   file deleted (there are no live bytes to probe or hash).
- */
-export declare function classifyBinaryOwnedFile(args: {
-    entry: {
-        status: string;
-        file: string;
-    };
-    engineDir: string;
-    patchesDir: string;
-    matchClassification: 'patch-backed' | 'furnace';
-    owner: string;
-    fileMissing?: boolean;
-    /** Batched lookup. When absent, falls back to per-file manifest queries. */
-    lookup?: AffectingPatchLookup;
-}): Promise<BinaryClassifiedFile | null>;

package/dist/src/core/status-binary.js

@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Binary-aware drift classification for patch-owned files.
- *
- * The text classifier compares utf-8 decoded content against
- * `computePatchedContent`, which cannot apply `GIT binary patch` bodies, so
- * a binary file exported into a patch classifies as `patch-owned-drift`
- * forever, keeping the engine-clean gate permanently red with nothing
- * actually un-durable. A `GIT binary patch` section does carry the ground
- * truth: `git diff --binary` always records full blob hashes on the section's
- * `index <old>..<new>` line. Comparing the live file's `git hash-object`
- * against the last owning section's new-side hash settles the classification
- * exactly. Bodies without a usable hash (hand-written diffs) classify as
- * `binary-unsupported`: an honest "cannot compare" instead of a false "not
- * durable".
- *
- * That hash is trusted only when the section carries a replayable payload
- * (`hasBinaryDelta`). A `Binary files … differ` stub carries a correct index
- * line too, so hashing against it reports `patch-backed` for a body that
- * cannot rebuild the file at all, which is the dishonesty this module
- * exists to avoid. Such a body is `binary-unsupported` here, and an error
- * from the `binary-body-not-reconstructable` queue lint.
- *
- * Lives in its own module (not `status-classify.ts`) so the classifier stays
- * within the per-file line budget and this module never has to import it
- * back: the dependency edge points one way, which keeps dpdm clean.
- */
-import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { readText } from '../utils/fs.js';
-import { verbose } from '../utils/logger.js';
-import { hashObjectBatch, isBinaryFile } from './git-file-ops.js';
-import { findPatchesAffectingFile } from './patch-manifest.js';
-import { parseDiffSections } from './patch-parse.js';
-/** Finds the LAST diff section affecting `file` across the owning patches, in queue order. */
-async function findLastAffectingSection(patchesDir, file, lookup) {
-    // The lookup shares one manifest load + memoized body reads across the
-    // whole classification batch. The fallback keeps single-file callers
-    // (and existing direct tests) working without a context.
-    const patches = lookup !== undefined
-        ? lookup.getAffectingPatches(file)
-        : (await findPatchesAffectingFile(patchesDir, file)).map(({ patch }) => patch);
-    let last;
-    for (const patch of patches) {
-        const body = lookup !== undefined ? await lookup.readPatchBody(patch) : await readText(patch.path);
-        for (const section of parseDiffSections(body)) {
-            if (section.targetPath === file || section.sourcePath === file) {
-                last = section;
-            }
-        }
-    }
-    return last;
-}
-/**
- * Classifies a single-owner file whose comparison is binary. Returns
- * `null` when the comparison is not binary (the live file is text and,
- * for deletions, the owning section is text), so the caller falls
- * through to the existing utf-8 content comparison unchanged.
- *
- * @param args.fileMissing - True when the porcelain status reports the
- *   file deleted (there are no live bytes to probe or hash).
- */
-export async function classifyBinaryOwnedFile(args) {
-    const { entry, engineDir, patchesDir, matchClassification, owner } = args;
-    const fileMissing = args.fileMissing === true;
-    const unsupported = () => ({
-        ...entry,
-        classification: 'binary-unsupported',
-        owner,
-    });
-    // Until the comparison is known to be binary, every failure defers to
-    // the existing text path (`return null`). Classifying a text file as
-    // `binary-unsupported` because a probe failed would hide real drift.
-    let section;
-    try {
-        if (!fileMissing) {
-            const liveBinary = await isBinaryFile(engineDir, entry.file);
-            if (!liveBinary)
-                return null;
-        }
-        section = await findLastAffectingSection(patchesDir, entry.file, args.lookup);
-    }
-    catch (error) {
-        if (fileMissing)
-            return null;
-        verbose(`Classifying ${entry.file} as binary-unsupported because the binary probe failed: ${toError(error).message}`);
-        return unsupported();
-    }
-    try {
-        if (section === undefined) {
-            // Claimed in filesAffected but no diff section touches the file.
-            // A missing file keeps the existing deletion logic. A live binary
-            // has nothing recorded to compare against.
-            return fileMissing ? null : unsupported();
-        }
-        if (!section.isBinary) {
-            // Text section: deletions settle fine through the text path. A
-            // live binary against a text body has no comparable recording.
-            return fileMissing ? null : unsupported();
-        }
-        if (section.isDeletedFile) {
-            return {
-                ...entry,
-                classification: fileMissing ? matchClassification : 'patch-owned-drift',
-                owner,
-            };
-        }
-        if (fileMissing) {
-            // The last binary section expects the file to exist.
-            return { ...entry, classification: 'patch-owned-drift', owner };
-        }
-        if (section.hasBinaryDelta && section.indexNewHash !== undefined) {
-            const fullPath = join(engineDir, entry.file);
-            const live = args.lookup?.liveBlobHash !== undefined
-                ? await args.lookup.liveBlobHash(fullPath)
-                : (await hashObjectBatch(engineDir, [fullPath])).get(fullPath);
-            if (live !== undefined) {
-                // Prefix-compare: recorded hashes may be abbreviated (≥7 chars).
-                const matches = live.startsWith(section.indexNewHash) || section.indexNewHash.startsWith(live);
-                return {
-                    ...entry,
-                    classification: matches ? matchClassification : 'patch-owned-drift',
-                    owner,
-                };
-            }
-        }
-        return unsupported();
-    }
-    catch (error) {
-        verbose(`Classifying ${entry.file} as binary-unsupported because the binary comparison failed: ${toError(error).message}`);
-        return unsupported();
-    }
-}