@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/types/recovery-journal.d.ts

@@ -1,248 +0,0 @@
-import type { WorkerOperationRecovery, WorkerOutputOffsets } from "./recovery-protocol";
-/**
- * The control-thread side of the worker's durable recovery journal.
- *
- * The SQLite store (WAL, `synchronous=FULL`) lives on the journal thread;
- * this facade owns one ordered channel of store operations and the ordered
- * delivery of the messages those operations make durable. Its invariants:
- *
- * - order: every entry is applied in append order, one durable commit per
- *   batch, so an `unknown` appended after a `record` applies after it, and an
- *   `admit` of a later request commits after the `record` of an earlier one;
- * - commit before send: a keyed message is written to the socket only after
- *   the batch holding its `record` committed, in append order, so a terminal
- *   never leaves before the output recorded ahead of it and a response is
- *   never acknowledged before it is durable;
- * - commit before effects: `admit` resolves after its commit; handlers run
- *   after it;
- * - bounded: everything the facade retains (entries waiting for the thread,
- *   entries in the batch being committed, and committed messages not yet
- *   drained to the socket) is charged to one general budget of entries and
- *   bytes, reserved atomically before anything is queued and released only
- *   when the item is actually done; unknown marks, acknowledgements and
- *   handshake reads use a separate reserved control budget. Output producers
- *   and admissions wait for budget in bounded waiting rooms; a result that
- *   cannot be buffered is never sent early: its operation is marked unknown,
- *   which is exactly what a crash would have left;
- * - fail closed: a thread exit, a failed batch, or an exhausted control budget
- *   fails every pending and future entry and reports once; the store is never
- *   re-opened in-process.
- */
-type Message = {
-    type: string;
-    [key: string]: unknown;
-};
-export declare const WORKER_RECOVERY_JOURNAL_MAX_BATCH_ENTRIES = 256;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_PENDING_ENTRIES = 4096;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_PENDING_BYTES: number;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_CONTROL_ENTRIES = 2048;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_CONTROL_BYTES: number;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_ENTRY_BYTES: number;
-export declare const WORKER_RECOVERY_JOURNAL_OUTPUT_CHUNK_CHARACTERS: number;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_WAITING_ADMISSIONS = 512;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_WAITING_OUTPUT = 1024;
-export declare const WORKER_RECOVERY_JOURNAL_MAX_WAITING_BYTES: number;
-export declare const WORKER_RECOVERY_JOURNAL_REPLAY_PAGE_FRAMES = 32;
-export declare class WorkerRecoveryJournalError extends Error {
-    readonly name: string;
-}
-/** The journal is intact but its bounded waiting room is full; the caller must not queue more. */
-export declare class WorkerRecoveryJournalBusyError extends WorkerRecoveryJournalError {
-    readonly name = "WorkerRecoveryJournalBusyError";
-}
-export type WorkerRecoveryJournalAdmission = {
-    admission: "new" | "duplicate" | "unknown" | "conflict";
-    response: Message | undefined;
-    cancelled: boolean;
-};
-export type WorkerRecoveryJournalRecoveryState = {
-    operations: WorkerOperationRecovery[];
-    cursors: WorkerOutputOffsets[];
-    responses: Message[];
-    terminals: Message[];
-};
-export type WorkerRecoveryJournalStatus = {
-    /** Entries waiting for the thread plus entries in the batch being committed. */
-    pendingEntries: number;
-    /** General budget in use: pending entries and undelivered messages, in entries and bytes. */
-    retainedEntries: number;
-    retainedBytes: number;
-    controlEntries: number;
-    controlBytes: number;
-    waitingAdmissions: number;
-    waitingOutput: number;
-    /** Payload bytes held by requests and output chunks waiting for budget. */
-    waitingBytes: number;
-    /** Bytes of store replies (handshake state, output pages) the caller has not consumed yet. */
-    retainedReplyBytes: number;
-    committedSeq: number;
-    appendedSeq: number;
-    undelivered: number;
-    failed: string | null;
-};
-export type WorkerRecoveryJournalOptions = {
-    filename: string;
-    threadModulePath?: string;
-    /** Extra `workerData` for the thread module (test fixtures only). */
-    threadWorkerData?: Record<string, unknown>;
-    log?: (line: string) => void;
-    maxBatchEntries?: number;
-    maxPendingEntries?: number;
-    maxPendingBytes?: number;
-    maxControlEntries?: number;
-    maxControlBytes?: number;
-    maxEntryBytes?: number;
-    maxWaitingAdmissions?: number;
-    maxWaitingOutput?: number;
-    maxWaitingBytes?: number;
-};
-export declare class WorkerRecoveryJournal {
-    readonly ledgerId: string;
-    private readonly worker;
-    private readonly log;
-    private readonly maxBatchEntries;
-    private readonly maxEntryBytes;
-    private readonly maxWaitingAdmissions;
-    private readonly maxWaitingOutput;
-    private readonly maxWaitingBytes;
-    private waitingBytes;
-    private retainedReplyBytes;
-    private readonly general;
-    private readonly control;
-    private nextSeq;
-    private committedSeq;
-    private readonly pending;
-    private inFlight;
-    private nextBatchId;
-    private readonly waiters;
-    private readonly outbound;
-    private deliveryPaused;
-    private replayCoveredSeq;
-    private failure;
-    private closed;
-    private readonly pendingAdmissions;
-    private readonly activeOperations;
-    private readonly cancelledRequestIds;
-    private readonly unknownRequestIds;
-    private readonly unknownRunIds;
-    private readonly coalescedControl;
-    private readonly flushWaiters;
-    /** Delivers one committed message in order; returns false when the transport declined it (the pumps re-send). */
-    deliver: ((message: Message) => boolean) | undefined;
-    /** Invoked once when the journal fails closed. */
-    onFailure: ((error: Error) => void) | undefined;
-    private constructor();
-    /** Start the journal thread, open the store there (its crash recovery runs there) and return once it is ready. */
-    static open(options: WorkerRecoveryJournalOptions): Promise<WorkerRecoveryJournal>;
-    status(): WorkerRecoveryJournalStatus;
-    /**
-     * Durably admit an inbound operation; resolves after the commit. Waits for
-     * general budget in a bounded waiting room; when that room is full the
-     * admission is refused at once (WorkerRecoveryJournalBusyError) so the
-     * message is neither acknowledged nor retained.
-     */
-    admit(message: Message & {
-        requestId: string;
-    }): Promise<WorkerRecoveryJournalAdmission>;
-    /**
-     * Re-admit an unknown branch deletion. Like `admit`, the request is a
-     * pending admission from before the await, so a session cancellation that
-     * lands while the disk is slow snapshots it and the handler's recheck after
-     * the await refuses to rerun the deletion.
-     */
-    readmitUnknownBranchDeletion(requestId: string, sessionId: string | undefined): Promise<boolean>;
-    /**
-     * Queue an outbound message. Keyed messages are recorded (when the store
-     * records their type) and delivered in order after their commit; other
-     * messages are delivered at once. Returns false when the message was not
-     * queued: its operation is already unknown, or the budget cannot hold it,
-     * in which case the operation is marked unknown so it is neither
-     * acknowledged early nor sent later.
-     */
-    send(message: Message): boolean;
-    /** Commit and deliver a result before an intentional runtime restart fences unfinished operations. */
-    sendAndFlush(message: Message): Promise<void>;
-    /**
-     * Queue an output frame, split into bounded records, waiting for budget so
-     * a stalled journal throttles the producer (and through the pipe, the
-     * child) instead of growing memory.
-     */
-    sendOutput(frame: Message & {
-        type: "exec_output";
-        runId: string;
-        stream: "stdout" | "stderr";
-        data: string;
-    }): Promise<void>;
-    /**
-     * Reserve general budget atomically, waiting in the bounded room of `kind`
-     * when it does not fit now. The waiting room is bounded in count and in
-     * payload bytes (the message a waiting admission holds is charged before it
-     * waits), and an entry that could never fit the general budget is refused
-     * at once rather than parked at the head of the queue.
-     */
-    private reserveGeneral;
-    /** Reserve for the head waiter inside this synchronous call, so no continuation can outrun the accounting. */
-    private wakeWaiters;
-    private enqueueRecord;
-    private refuse;
-    private trackRecorded;
-    /**
-     * Mark an operation unknown: never sent again (undelivered messages for it
-     * are dropped now, and the durable mark keeps replay from resurrecting it).
-     * Coalesced per id; uses the reserved control budget.
-     */
-    unknown(requestId: string): void;
-    unknownRun(runId: string): void;
-    acknowledgeResult(requestId: string): void;
-    /** Monotonic per stream: a later acknowledgement replaces a pending earlier one. */
-    acknowledgeOutput(runId: string, stream: "stdout" | "stderr", offset: number): void;
-    acknowledgeTerminal(runId: string): void;
-    /**
-     * Snapshot every admitted and pending operation of the session as cancelled
-     * (the handlers check `isRequestCancelled` at their fences) and append the
-     * durable cancellation, which the thread applies after every admission
-     * appended before it. Resolves after the commit.
-     */
-    cancelSession(sessionId: string): Promise<void>;
-    isRequestCancelled(requestId: string): boolean;
-    /** Every operation admitted or awaiting admission in this process that has not completed, for the runtime fence and lease expiry. */
-    activeAndPendingOperations(): WorkerOperationRecovery[];
-    /**
-     * The handshake read. One entry, so it sees exactly the entries appended
-     * before it and none after: the replay boundary. Callers pause delivery
-     * before appending it and resume after the handshake, so every keyed
-     * message committed before the mark is replayed once (from the store) and
-     * nothing committed after it can enter the replay of responses, operations
-     * or terminals; output pages that follow may re-send frames the pump would
-     * re-send anyway, which the server's offset cursors absorb.
-     */
-    recoveryState(requests: string[]): Promise<WorkerRecoveryJournalRecoveryState>;
-    private retainedStateBytes;
-    /** Output replay, one bounded page at a time; a page is accounted until the consumer asks for the next one. */
-    outputReplay(offsets: WorkerOutputOffsets[] | undefined, pageFrames?: number): AsyncGenerator<Message[]>;
-    terminals(): Promise<Message[]>;
-    /** Delivery of committed keyed messages is held (in order) while a handshake replays from the store. */
-    pauseDelivery(): void;
-    resumeDelivery(): void;
-    /** Resolves once every entry appended so far is committed (or the journal failed). */
-    flush(): Promise<void>;
-    close(): void;
-    private assertOpen;
-    /** Control entries are tiny and idempotent per key: a pending one is updated in place instead of queued again. */
-    private appendControl;
-    /** A control-budget entry whose result the caller awaits; rejects when the budget is exhausted. */
-    private appendControlOrThrow;
-    private lastAppended;
-    /** Queue an entry whose budget was already reserved from `budget`. */
-    private append;
-    private dispatch;
-    private onReply;
-    private dropOutbound;
-    private releaseOutbound;
-    private deliverReady;
-    private fail;
-    private failEntries;
-}
-/** The packaged thread module lives next to this module with the same extension (.ts in source, .cjs/.mjs in the package). */
-export declare function workerRecoveryJournalThreadModulePath(): string;
-export {};

package/dist/types/recovery-output-window.d.ts

@@ -1,19 +0,0 @@
-import type { WorkerOutputOffsets } from "./recovery-protocol";
-export type WorkerOutputFrame = {
-    type: "exec_output";
-    runId: string;
-    stream: "stdout" | "stderr";
-    offset: number;
-    data: string;
-};
-/** Bound outstanding application bytes, including data already buffered by the server's socket. */
-export declare class WorkerOutputWindow {
-    private readonly windowBytes;
-    private sent;
-    private acknowledged;
-    private outstanding;
-    constructor(windowBytes?: number);
-    reset(cursors: WorkerOutputOffsets[]): void;
-    send(frame: WorkerOutputFrame, send: (frame: WorkerOutputFrame) => boolean, bufferedAmount?: number): boolean;
-    acknowledge(runId: string, stream: "stdout" | "stderr", offset: number): void;
-}

package/dist/types/recovery-protocol.d.ts

@@ -1,59 +0,0 @@
-/** The application protocol survives replacement of its WebSocket transport. */
-export declare const WORKER_RESUMABLE_PROTOCOL: 1;
-export declare const WORKER_RECOVERY_TIMEOUT_MS: number;
-export type WorkerOperationRecovery = {
-    requestId: string;
-    runId?: string;
-    sessionId?: string;
-    requestType?: string;
-    state: "accepted" | "preparing" | "running" | "completed" | "unknown";
-};
-export type WorkerOutputOffsets = {
-    runId: string;
-    stdoutBytes: number;
-    stderrBytes: number;
-};
-export type WorkerRecoveryServerMessage = {
-    type: "recovery_request";
-    recoveryId: string;
-    requests: string[];
-    outputOffsets: WorkerOutputOffsets[];
-} | {
-    type: "recovery_ready";
-    recoveryId: string;
-    leaseMs: number;
-} | {
-    type: "operation_result_ack";
-    requestId: string;
-} | {
-    type: "exec_output_ack";
-    runId: string;
-    stream: "stdout" | "stderr";
-    nextOffset: number;
-} | {
-    type: "worker_execution_lease";
-    leaseMs: number;
-} | {
-    type: "cancel_session";
-    sessionId: string;
-    cancellationId: string;
-};
-export type WorkerRecoveryClientMessage = {
-    type: "recovery_state";
-    recoveryId: string;
-    runtimeId: string;
-    ledgerId: string;
-    operations: WorkerOperationRecovery[];
-} | {
-    type: "recovery_complete";
-    recoveryId: string;
-} | {
-    type: "operation_received";
-    requestId: string;
-} | {
-    type: "operation_completed";
-    requestId: string;
-} | {
-    type: "cancel_session_ack";
-    cancellationId: string;
-};

package/dist/types/recovery-store.d.ts

@@ -1,52 +0,0 @@
-import type { WorkerOperationRecovery, WorkerOutputOffsets } from "./recovery-protocol";
-type Message = {
-    type: string;
-    [key: string]: unknown;
-};
-/** Stable semantic identity, independent of JSON key order and transport request aliases. */
-export declare function workerOperationDigest(message: Message): string;
-/** The receipt is committed before a handler can mutate anything. Unknown crash outcomes never replay effects. */
-export declare class WorkerRecoveryStore {
-    private readonly db;
-    readonly ledgerId: string;
-    constructor(filename: string);
-    close(): void;
-    /**
-     * Run several store operations as one durable commit (one FULL fsync).
-     * Operations that open their own transaction nest as savepoints. A throw
-     * rolls the whole group back; callers treat that as a journal failure.
-     */
-    batch<T>(operations: () => T): T;
-    private row;
-    admit(message: Message & {
-        requestId: string;
-    }): "new" | "duplicate" | "unknown" | "conflict";
-    isUnknown(requestId: string): boolean;
-    /**
-     * Re-admit an operation whose crash outcome is unknown so it can run again
-     * and record a result. Only a branch deletion qualifies: it is idempotent
-     * for its exact incarnation (durable tombstone plus incarnation preflight),
-     * so a rerun converges on the same outcome. Every other unknown operation
-     * keeps the no-replay invariant.
-     */
-    readmitUnknownBranchDeletion(requestId: string): boolean;
-    unknown(requestId: string): void;
-    unknownRun(runId: string): void;
-    record(message: Message): Message;
-    operations(): WorkerOperationRecovery[];
-    response(requestId: string): Message | undefined;
-    responses(requestIds: string[]): Message[];
-    lengths(runId: string): {
-        stdoutBytes: number;
-        stderrBytes: number;
-    };
-    outputCursors(): WorkerOutputOffsets[];
-    output(offsets?: WorkerOutputOffsets[]): Generator<Message>;
-    terminals(): Message[];
-    acknowledgeOutput(runId: string, stream: "stdout" | "stderr", offset: number): void;
-    acknowledgeResult(requestId: string): void;
-    acknowledgeTerminal(runId: string): void;
-    cancelSession(sessionId: string): void;
-    isRequestCancelled(requestId: string): boolean;
-}
-export {};

package/dist/types/registry-auth.d.ts

@@ -1,47 +0,0 @@
-export declare const APP_MANAGED_GITHUB_REGISTRY: "ghcr.io";
-export type GitHubRegistryCredential = {
-    registry: typeof APP_MANAGED_GITHUB_REGISTRY;
-    username: string;
-    token: string;
-};
-export declare class RegistryAuthConfigurationError extends Error {
-    constructor(cause: unknown);
-}
-export declare function registryAuthHasAppManagedGitHubCredential(filePath: string): boolean;
-type DirectoryFsyncDependencies = {
-    platform: NodeJS.Platform;
-    open: (directory: string) => number;
-    fsync: (descriptor: number) => void;
-    close: (descriptor: number) => void;
-};
-declare function fsyncDirectory(directory: string, dependencies?: DirectoryFsyncDependencies): void;
-export type PrivateAuthFileUpdate = {
-    filePath: string;
-    content: string | null;
-    allowSymlinkRemoval?: boolean;
-};
-export type PreparedPrivateAuthFileGeneration = {
-    readonly changed: boolean;
-    commit(beforeMutation?: (filePath: string, index: number) => void): void;
-    discard(): void;
-};
-/**
- * Validate and fsync every replacement before exposing the first new auth
- * byte. Cross-file publication is necessarily sequential, so callers must
- * fence/terminate the previous process generation before commit and treat any
- * commit error as a fatal partial-generation boundary.
- */
-export declare function preparePrivateAuthFileGeneration(updates: readonly PrivateAuthFileUpdate[]): PreparedPrivateAuthFileGeneration;
-export declare function planGitHubRegistryAuthFiles(filePaths: readonly string[], credential: GitHubRegistryCredential | null): PrivateAuthFileUpdate[];
-/**
- * Authoritatively replace the app-owned ghcr.io entry while retaining every
- * unrelated Docker/containers auth entry and top-level setting.
- */
-export declare function updateGitHubRegistryAuthFile(filePath: string, credential: GitHubRegistryCredential | null): void;
-export declare function configureGitHubRegistryAuthFiles(filePaths: readonly string[], credential: GitHubRegistryCredential | null): void;
-export declare const registryAuthTestHarness: {
-    fsyncDirectory: typeof fsyncDirectory;
-    atomicReplacePrivateFile(filePath: string, content: string, beforeRename?: () => void): void;
-    configureFiles(filePaths: readonly string[], credential: GitHubRegistryCredential | null, beforeRename: (filePath: string, index: number) => void): void;
-};
-export {};

package/dist/types/repository-transition-policy.d.ts

@@ -1,26 +0,0 @@
-export type WorkerRepositoryTransitionState = {
-    repositoryTransitionId: string | null;
-    executionDisabled: boolean;
-    mirrorWritesDisabled: boolean;
-};
-export type LastEnabledRepositoryTransition = {
-    known: boolean;
-    transitionId: string | null;
-};
-export declare function assertRepositoryTransitionState(project: WorkerRepositoryTransitionState & {
-    projectId: string;
-}): void;
-/** Disabled repositories retain their local state but expose no execution root. */
-export declare function assertRepositoryExecutionEnabled(project: Pick<WorkerRepositoryTransitionState, "executionDisabled"> & {
-    projectId: string;
-}): void;
-/** Every hidden-mirror ref mutation, including deletion, uses this fence. */
-export declare function repositoryMirrorWritesAllowed(project: Pick<WorkerRepositoryTransitionState, "executionDisabled" | "mirrorWritesDisabled"> | undefined): boolean;
-/**
- * A disabled snapshot never consumes the reseed obligation. Missing durable
- * history is treated conservatively after restart and reseeded once enabled.
- */
-export declare function enabledRepositoryTransitionRequiresReseed(input: {
-    project: Pick<WorkerRepositoryTransitionState, "repositoryTransitionId" | "executionDisabled">;
-    lastEnabled: LastEnabledRepositoryTransition;
-}): boolean;

package/dist/types/runtime-version.d.ts

@@ -1 +0,0 @@
-export declare const WORKER_RUNTIME_VERSION: string;

package/dist/types/session-file-mutations.d.ts

@@ -1,22 +0,0 @@
-/**
- * File mutations (write, edit, plan updates) run on the asynchronous
- * filesystem API, so a write can still be in flight when a session is
- * stopped. A Stop acknowledges cleanup only after every mutation that had
- * already started for the session has actually settled; mutations that were
- * still queued re-check the session's cancellation immediately before their
- * first write and never start. The tracker records the former; the admission
- * fence inside each mutation's queue callback provides the latter.
- */
-export declare class SessionFileMutationTracker {
-    private readonly inFlight;
-    /** Register a started mutation; it is forgotten when it settles, however it settles. */
-    track<T>(sessionId: string, mutation: Promise<T>): Promise<T>;
-    count(sessionId: string): number;
-    /**
-     * Resolves once every mutation tracked for the session at the time of the
-     * call has settled. Mutations started later are not joined: the session's
-     * cancellation marker, recorded before this is awaited, makes their
-     * admission recheck refuse them.
-     */
-    settled(sessionId: string): Promise<void>;
-}

package/dist/types/supervisor-daemonized-fixture.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/supervisor-launcher-cleanup-fixture.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/supervisor-signal-fixture.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/supervisor.d.ts

@@ -1,23 +0,0 @@
-import { type KillableSubprocess } from "./process-tree";
-export declare const WORKER_RUNTIME_ENV = "R5D_WORKER_INTERNAL_RUNTIME";
-export declare const WORKER_RELOAD_EXIT_CODE = 75;
-export declare const WORKER_RECONNECT_EXIT_CODE = 76;
-export declare const WORKER_CREDENTIAL_RESTART_EXIT_CODE = 77;
-export declare const WORKER_RECONNECT_DELAY_MS = 2000;
-export declare const WORKER_RECONNECT_JITTER_MS = 3000;
-export declare const WORKER_RECONNECT_MAX_DELAY_MS = 30000;
-type RuntimeProcess = KillableSubprocess;
-export type RuntimeSpawner = (argv: string[], options: {
-    stdin: "inherit";
-    stdout: "inherit";
-    stderr: "inherit";
-    detached: true;
-    env: Record<string, string | undefined>;
-}) => RuntimeProcess;
-export type RuntimeDelay = (delayMs: number) => Promise<void>;
-export type RuntimeReaper = (runtime: RuntimeProcess) => Promise<void>;
-export type RuntimeReconnectDelay = () => number;
-export declare function workerReconnectDelayMs(random?: () => number, attempt?: number): number;
-export declare function isRetryableWorkerServerStatus(status: number): boolean;
-export declare function superviseWorkerRuntime(argv: string[], env?: Record<string, string | undefined>, spawnRuntime?: RuntimeSpawner, waitBeforeReconnect?: RuntimeDelay, reapCredentialRuntime?: RuntimeReaper, reconnectDelay?: RuntimeReconnectDelay): Promise<number>;
-export {};

package/dist/types/three-way-merge.d.ts

@@ -1,77 +0,0 @@
-/**
- * Pure three-way line merge (classic diff3) for merge hydration.
- *
- * The verdict is deliberately conservative: a false conflict only pins a
- * mount for a cycle, while a false clean silently loses one side's edit. Git
- * picks one of possibly many minimal diffs per side and its verdict depends on
- * which, so instead of trusting one alignment this merge only treats a base
- * line as stable when every minimal diff agrees on it, and only accepts an
- * identical change from both sides when its alignment is unique. That keeps
- * the clean verdict a subset of `git merge-file`'s for every minimal diff Git
- * could choose, and clean output byte-identical to `git merge-file -p ours
- * base theirs`; the differential test enforces both.
- */
-export type ThreeWayMergeOptions = {
-    /** Sides with more lines than this are not merged (conflict). */
-    maxLines?: number;
-    /** Two-way diffs with more line edits than this are not merged (conflict); bounds the O((N+M)D) diff. */
-    maxEditDistance?: number;
-    /** Bound on the banded (lines × edits) alignment analysis per side; beyond it the merge conflicts. */
-    maxAlignmentCells?: number;
-    /** Bound on the diagonal visits one two-way diff may spend; beyond it the merge conflicts. */
-    maxDiffWork?: number;
-};
-export type ThreeWayMergeResult = {
-    kind: "clean";
-    content: Buffer;
-} | {
-    kind: "conflict";
-    conflicts: number;
-};
-/** A changed region of a two-way diff: `a[aStart, aEnd)` was replaced by `b[bStart, bEnd)`. */
-export type DiffHunk = {
-    aStart: number;
-    aEnd: number;
-    bStart: number;
-    bEnd: number;
-};
-/** What every minimal diff of a side against the base agrees on, per base line. */
-export type SideAlignment = {
-    /** Base line -> the side line it is matched to in every minimal diff, or -1. */
-    certain: Int32Array;
-    /** 1 where minimal diffs disagree: matched to different side lines, or matched in some and deleted in others. */
-    ambiguous: Uint8Array;
-};
-type LineSequence = ArrayLike<number>;
-/** Git's `buffer_is_binary`: a NUL byte within the first 8000 bytes. */
-export declare function isBinaryContent(content: Buffer): boolean;
-/**
- * Minimal line diff `a` -> `b` as ordered, non-touching hunks, or null when
- * the edit distance exceeds `maxEditDistance`. Divide and conquer on the
- * middle snake keeps memory linear; the explicit stack keeps deep, lopsided
- * splits off the call stack. The merge only needs the edit distance from it,
- * the hunks are one of the minimal diffs.
- */
-export declare function diffLines(a: LineSequence, b: LineSequence, options?: {
-    maxEditDistance?: number;
-    maxWork?: number;
-}): DiffHunk[] | null;
-/**
- * Classifies every base line by what all minimal diffs `a` -> `b` agree on,
- * given the length of their common subsequence.
- *
- * A minimal diff crosses from base line i to i + 1 either by deleting line i
- * or by matching it to some b[j]; the crossing is on a minimal diff exactly
- * when prefix LCS + suffix LCS (+ 1 for a match) reaches `lcsLength`. Both
- * tables are only needed on the diagonal band any minimal diff stays within,
- * so the cost is (lines × edits): suffix rows are checkpointed every √N rows
- * and recomputed per block, prefix rows roll forward. Returns null once the
- * band exceeds `maxCells`, which the caller treats as a conflict.
- */
-export declare function analyzeAlignment(a: LineSequence, b: LineSequence, lcsLength: number, maxCells: number): SideAlignment | null;
-export declare function mergeThreeWay(base: Buffer, ours: Buffer, theirs: Buffer, options?: ThreeWayMergeOptions): ThreeWayMergeResult;
-export declare const threeWayMergeTestHarness: {
-    diffLines: typeof diffLines;
-    analyzeAlignment: typeof analyzeAlignment;
-};
-export {};