@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/git/integration.js

@@ -1,6 +1,7 @@
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { gitObjectId, gitObjectIdForSnapshot, mintChangeId, mintSnapshotId } from "./identity.js";
-import { decodeGitNameOnly, decodeGitNumstat, GitPlumbingError, readRef, runGit, runGitWithEnvironment, } from "./repository.js";
+import { decodeGitNameOnly, decodeGitNumstat, readRef, } from "./repository.js";
+import { GitPlumbingError, runGit, runGitWithEnvironment, } from "./process.js";
 const REQUIRED_GIT = "2.38";
 async function runAllowingNonzero(repository, args, input) {
     try {
@@ -55,6 +56,58 @@ export async function materializeIntegrationSnapshot(repository, tree, parent, m
     })).toString("utf8").trim();
     return mintSnapshotId(commit);
 }
+export async function persistedTender(repository, snapshot) {
+    const tree = (await runGit(repository, ["show", "-s", "--format=%T", gitObjectIdForSnapshot(snapshot)]))
+        .toString("ascii")
+        .trim();
+    return { head: snapshot, tree: gitObjectId(tree, "persisted tender tree") };
+}
+export async function materializeReintegrationSnapshot(repository, tree, parent, template) {
+    const templateObject = gitObjectIdForSnapshot(template);
+    let raw;
+    try {
+        raw = await runGit(repository, ["cat-file", "commit", templateObject]);
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError) {
+            throw new AuthorityCorruptionError(`recorded delivery snapshot cannot be read: ${template}`);
+        }
+        throw error;
+    }
+    const separator = raw.indexOf(Buffer.from("\n\n"));
+    if (separator < 0)
+        throw new AuthorityCorruptionError(`recorded delivery snapshot has no commit message: ${template}`);
+    const message = raw.subarray(separator + 2);
+    let fields;
+    try {
+        const formatted = (await runGit(repository, [
+            "show",
+            "-s",
+            "--format=%an%x00%ae%x00%aI%x00%cn%x00%ce%x00%cI",
+            templateObject,
+        ])).toString("utf8").replace(/\n$/u, "");
+        fields = formatted.split("\0");
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError) {
+            throw new AuthorityCorruptionError(`recorded delivery snapshot metadata cannot be read: ${template}`);
+        }
+        throw error;
+    }
+    if (fields.length !== 6 || fields.some((field) => field.length === 0)) {
+        throw new AuthorityCorruptionError(`recorded delivery snapshot metadata is malformed: ${template}`);
+    }
+    const [authorName, authorEmail, authorDate, committerName, committerEmail, committerDate] = fields;
+    const commit = (await runGitWithEnvironment(repository, ["commit-tree", tree, "-p", gitObjectIdForSnapshot(parent)], message, {
+        GIT_AUTHOR_NAME: authorName,
+        GIT_AUTHOR_EMAIL: authorEmail,
+        GIT_AUTHOR_DATE: authorDate,
+        GIT_COMMITTER_NAME: committerName,
+        GIT_COMMITTER_EMAIL: committerEmail,
+        GIT_COMMITTER_DATE: committerDate,
+    })).toString("utf8").trim();
+    return mintSnapshotId(commit);
+}
 async function isAncestor(repository, ancestor, descendant) {
     const result = await runAllowingNonzero(repository, [
         "merge-base",
@@ -139,6 +192,44 @@ async function mergedTree(repository, contractId, base, targetHead, tenderTree)
         message: "git merge-tree --write-tree failed",
     });
 }
+/** True when the appointed workspace already has Git MERGE_HEAD. */
+export async function workspaceMergeStatePresent(repository, workspace) {
+    const result = await runAllowingNonzero(repository, [
+        "-C",
+        workspace,
+        "rev-parse",
+        "-q",
+        "--verify",
+        "MERGE_HEAD",
+    ]);
+    if (result.status === 0)
+        return true;
+    if (result.status === 1)
+        return false;
+    throw new GitPlumbingError({
+        stderr: result.stderr,
+        status: result.status,
+        message: "git rev-parse --verify MERGE_HEAD failed",
+    });
+}
+/** Project the already-judged conflict as `git merge --no-commit <targetHead>`. */
+export async function materializeJudgedConflict(repository, workspace, targetHead) {
+    const result = await runAllowingNonzero(repository, [
+        "-C",
+        workspace,
+        "merge",
+        "--no-commit",
+        gitObjectIdForSnapshot(targetHead),
+    ]);
+    if (result.status === 0 || result.status === 1)
+        return;
+    throw new GitPlumbingError({
+        stdout: result.stdout,
+        stderr: result.stderr,
+        status: result.status,
+        message: "git merge --no-commit failed",
+    });
+}
 export async function planIntegration(repository, input, tender, requireBranchesToBeUpToDate) {
     const target = input.coordinates.target;
     if (target === undefined) {

package/build/src/git/nuke.d.ts

@@ -0,0 +1,2 @@
+import type { WorldRoot } from "../world.js";
+export declare function nukeGit(world: WorldRoot): Promise<void>;

package/build/src/git/nuke.js

@@ -0,0 +1,97 @@
+import { access } from "node:fs/promises";
+import { nukeContractWorktreeLock, nukeHereAppointments } from "../contract-worktree.js";
+import { nukeSettlementFences } from "../settlement/fence.js";
+import { nukeEmptyPlaceAuthority, readPlaceRegister, releaseManagedWorktrees, } from "../workspace-place.js";
+import { nukeWorktreeHookResidue } from "./hooks.js";
+import { nukeReconcileLocks } from "./reconcile.js";
+import { runGit } from "./process.js";
+import { NoGitWorldError, registeredWorktrees, repositoryAt, worktreeGitDirectory } from "./repository.js";
+import { worktreePath } from "./workspace.js";
+async function managedCustody(repository) {
+    const register = await readPlaceRegister(repository);
+    const topology = new Map((await registeredWorktrees(repository)).map((entry) => [entry.path, entry]));
+    const entries = [];
+    for (const appointment of register.appointments) {
+        const path = worktreePath(repository, appointment.place);
+        const registered = topology.get(path);
+        if (registered === undefined) {
+            try {
+                await access(path);
+            }
+            catch {
+                entries.push({ contract: appointment.contract, path });
+                continue;
+            }
+            throw new Error(`managed Place path has foreign custody: ${path}`);
+        }
+        if (registered.branch !== null)
+            throw new Error(`managed Place path has a branch: ${path}`);
+        entries.push({ contract: appointment.contract, path });
+    }
+    const refs = (await runGit(repository, [
+        "for-each-ref", "--format=%(refname)", "refs/heads/keiyaku-delivery", "refs/heads/keiyaku-candidate",
+    ])).toString("utf8").split("\n").filter((ref) => ref.length > 0);
+    const state = await runGit(repository, ["show-ref", "--verify", "--quiet", "refs/heads/keiyaku-state"])
+        .then(() => true, () => false);
+    return { entries, refs, state };
+}
+async function removeManagedWorktree(repository, entry) {
+    const topology = await registeredWorktrees(repository);
+    const registered = topology.find((candidate) => candidate.path === entry.path);
+    if (registered === undefined) {
+        try {
+            await access(entry.path);
+        }
+        catch {
+            return;
+        }
+        throw new Error(`managed Place path has foreign custody: ${entry.path}`);
+    }
+    if (registered.branch !== null)
+        throw new Error(`managed Place path has a branch: ${entry.path}`);
+    await nukeWorktreeHookResidue(await worktreeGitDirectory(repository, entry.path));
+    await runGit(repository, ["worktree", "remove", "--force", entry.path]);
+    if ((await registeredWorktrees(repository)).some((candidate) => candidate.path === entry.path)) {
+        throw new Error(`managed Place worktree remains registered: ${entry.path}`);
+    }
+    try {
+        await access(entry.path);
+    }
+    catch {
+        return;
+    }
+    throw new Error(`managed Place worktree remains present: ${entry.path}`);
+}
+async function removeOwnedRefs(repository, refs) {
+    for (const ref of refs) {
+        const oid = (await runGit(repository, ["rev-parse", "--verify", "--quiet", ref])).toString("utf8").trim();
+        if (oid.length > 0)
+            await runGit(repository, ["update-ref", "--no-deref", "-d", ref, oid]);
+    }
+}
+export async function nukeGit(world) {
+    let repository;
+    try {
+        repository = await repositoryAt(world);
+    }
+    catch (error) {
+        if (error instanceof NoGitWorldError)
+            return;
+        throw error;
+    }
+    const custody = await managedCustody(repository);
+    for (const entry of custody.entries) {
+        await removeManagedWorktree(repository, entry);
+        await releaseManagedWorktrees(repository, [entry.contract]);
+    }
+    await nukeHereAppointments(repository);
+    await nukeEmptyPlaceAuthority(repository);
+    await nukeContractWorktreeLock(repository);
+    await nukeReconcileLocks(repository);
+    await nukeSettlementFences(repository);
+    await removeOwnedRefs(repository, custody.refs);
+    if (custody.state) {
+        const oid = (await runGit(repository, ["rev-parse", "--verify", "refs/heads/keiyaku-state"])).toString("utf8").trim();
+        await runGit(repository, ["update-ref", "--no-deref", "-d", "refs/heads/keiyaku-state", oid]);
+    }
+}

package/build/src/git/observe.d.ts

@@ -1,6 +1,7 @@
 import { type ContractId, type ContractState, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
 import type { ContractsObservation } from "../core/facts/observation.js";
-import { type GitSnapshot, type GitOid, type GitRepository } from "./repository.js";
+import { type GitSnapshot, type GitOid } from "./repository.js";
+import { type GitRepository } from "./process.js";
 import { type GitDecodeChannel, type GitReadObservation, type GitTreeSelection } from "./read-observation.js";
 export type TargetObservation = Readonly<{
     head: SnapshotId | null;

package/build/src/git/observe.js

@@ -2,7 +2,8 @@ import { decodeJournal } from "../core/facts/codec.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { contractJournalPath, contractJournalPaths, mintContractHead, mintSnapshotId, } from "./identity.js";
-import { GitPlumbingError, isKeiyakuOwnedRef, runGit, } from "./repository.js";
+import { isKeiyakuOwnedRef, } from "./repository.js";
+import { GitPlumbingError, runGit } from "./process.js";
 import { readGitTreeSelection, withGitTargetedReadObservation, } from "./read-observation.js";
 export async function observeDeliveryTargetAt(observation, state) {
     const target = state.coordinates.target;
@@ -10,12 +11,12 @@ export async function observeDeliveryTargetAt(observation, state) {
         return null;
     const value = await observation.resolveRef(target);
     const head = value === null ? null : mintSnapshotId(value);
-    const delivery = state.delivery?.data;
-    if (delivery === undefined)
+    const integration = state.currentIntegration;
+    if (integration === null)
         return { head, drift: false };
     const expected = state.terminal?.kind === "claimed"
-        ? delivery.integration.snapshot
-        : delivery.integration.predecessor;
+        ? integration.snapshot
+        : integration.predecessor;
     return { head, drift: head !== expected };
 }
 const TARGET_COORDINATES_FORMAT = "%(refname)%00%(objectname)%00";

package/build/src/git/process.d.ts

@@ -0,0 +1,28 @@
+export type GitRepository = Readonly<{
+    /** The executable selected when this repository capability is created. */
+    readonly gitPath: string;
+    /** The invocation's effective working directory, including a caller -C worktree. */
+    readonly effectiveCwd: string;
+    /** The worktree root containing the invocation's effective working directory. */
+    readonly invocationWorktree: string;
+    /** The canonical primary worktree root for this repository. */
+    readonly primaryWorktree: string;
+    /** The canonical common Git directory pinned when this capability is created. */
+    readonly commonDirectory: string;
+}>;
+export declare class GitPlumbingError extends Error {
+    readonly stdout: Buffer;
+    readonly stderr: Buffer;
+    readonly status: number | null;
+    readonly pid: number | null;
+    constructor(input: Readonly<{
+        stdout?: string | Uint8Array;
+        stderr: string | Uint8Array;
+        status: number | null;
+        message: string;
+        pid?: number | null;
+    }>);
+}
+export declare function runGit(repository: GitRepository, args: readonly string[], input?: string | Uint8Array): Promise<Buffer>;
+export declare function consumeGitStdout(repository: GitRepository, args: readonly string[], consume: (chunk: Buffer) => void): Promise<void>;
+export declare function runGitWithEnvironment(repository: GitRepository, args: readonly string[], input: string | Uint8Array | undefined, environment: NodeJS.ProcessEnv): Promise<Buffer>;

package/build/src/git/process.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import { consumeProcessStdout } from "../runtime/proc/run.js";
+export class GitPlumbingError extends Error {
+    stdout;
+    stderr;
+    status;
+    pid;
+    constructor(input) {
+        super(input.message);
+        this.name = "GitPlumbingError";
+        this.stdout = Buffer.from(input.stdout ?? "");
+        this.stderr = Buffer.from(input.stderr);
+        this.status = input.status;
+        this.pid = input.pid ?? null;
+    }
+}
+const GIT_STDERR_BYTES = 16 * 1024;
+function commandError(command, error) {
+    const candidate = error;
+    const stderr = candidate.stderr === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stderr);
+    const stdout = candidate.stdout === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stdout);
+    const detail = stderr.length === 0 ? candidate.message ?? "git command failed" : stderr.toString("utf8");
+    return new GitPlumbingError({
+        stdout,
+        stderr,
+        status: candidate.status ?? null,
+        message: `${command.join(" ")}: ${detail}`,
+        pid: candidate.pid ?? null,
+    });
+}
+async function executeGit(repository, args, input, environment) {
+    const stdout = [];
+    const stderr = [];
+    let stderrBytes = 0;
+    let inputError;
+    const child = spawn(repository.gitPath, [...args], {
+        cwd: repository.effectiveCwd,
+        ...(environment === undefined ? {} : { env: { ...process.env, ...environment } }),
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => {
+        if (stderrBytes >= GIT_STDERR_BYTES)
+            return;
+        const retained = chunk.subarray(0, GIT_STDERR_BYTES - stderrBytes);
+        stderr.push(retained);
+        stderrBytes += retained.length;
+    });
+    child.stdin.on("error", (error) => { inputError = error; });
+    child.stdin.end(input);
+    const terminal = await new Promise((resolveTerminal) => {
+        child.once("error", (error) => resolveTerminal({ code: null, error }));
+        child.once("close", (code) => resolveTerminal({ code }));
+    });
+    const output = Buffer.concat(stdout);
+    if (terminal.code === 0 && inputError === undefined)
+        return output;
+    throw commandError(args, {
+        message: terminal.error?.message ?? inputError?.message ?? `git exited with status ${terminal.code ?? "unknown"}`,
+        stdout: output,
+        stderr: Buffer.concat(stderr),
+        status: terminal.code,
+        pid: child.pid,
+    });
+}
+export async function runGit(repository, args, input) {
+    return await executeGit(repository, args, input);
+}
+export async function consumeGitStdout(repository, args, consume) {
+    const result = await consumeProcessStdout({
+        argv: [repository.gitPath, ...args],
+        cwd: repository.effectiveCwd,
+    }, consume);
+    const { outcome } = result;
+    if (outcome.kind === "terminal" && outcome.code === 0)
+        return;
+    const status = outcome.kind === "terminal" ? outcome.code : null;
+    const stderr = outcome.kind === "terminal" ? outcome.stderr : "";
+    const message = outcome.kind === "terminal"
+        ? `git exited with status ${outcome.code}`
+        : outcome.kind === "spawn-error" || outcome.kind === "stream-error"
+            ? outcome.diagnostic
+            : `git process ended with ${outcome.kind}`;
+    throw commandError(args, {
+        message,
+        stderr,
+        status,
+        pid: result.pid ?? undefined,
+    });
+}
+export async function runGitWithEnvironment(repository, args, input, environment) {
+    return await executeGit(repository, args, input, environment);
+}

package/build/src/git/read-observation.d.ts

@@ -1,5 +1,6 @@
 import { type TreeEntry } from "./tree.js";
-import { type GitOid, type GitRepository, type GitSnapshot } from "./repository.js";
+import { type GitOid, type GitSnapshot } from "./repository.js";
+import { type GitRepository } from "./process.js";
 declare const gitReadObservationBrand: unique symbol;
 declare const gitDecodeChannelBrand: unique symbol;
 export type GitBlobResult = Readonly<{

package/build/src/git/read-observation.js

@@ -2,7 +2,8 @@ import { spawn } from "node:child_process";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { gitObjectId } from "./identity.js";
 import { parseTreeObject, validPath } from "./tree.js";
-import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, GitPlumbingError, readRef, } from "./repository.js";
+import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readRef, } from "./repository.js";
+import { GitPlumbingError } from "./process.js";
 const gitReadObservationBrand = Symbol("GitReadObservation");
 const gitDecodeChannelBrand = Symbol("GitDecodeChannel");
 function streamCursor(stream) {
@@ -36,7 +37,7 @@ function streamCursor(stream) {
     return { line, exact };
 }
 function batchObjectReader(repository) {
-    const child = spawn("git", ["cat-file", "--batch"], {
+    const child = spawn(repository.gitPath, ["cat-file", "--batch"], {
         cwd: repository.effectiveCwd,
         stdio: ["pipe", "pipe", "pipe"],
         windowsHide: true,

package/build/src/git/reconcile.d.ts

@@ -1,4 +1,5 @@
-import { type GitOid, type GitRepository } from "./repository.js";
+import { type GitOid } from "./repository.js";
+import { type GitRepository } from "./process.js";
 import type { ContractId, ContractState, SnapshotId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "./read-observation.js";
 import { type TargetCheckoutEffect, type TargetCheckoutLag } from "./target-placement.js";
@@ -63,4 +64,6 @@ type ReconcileBatchOptions = Readonly<{
 }>;
 /** Reconcile each discovered Contract through its own serialized, fresh observation. */
 export declare function reconcileBatch(repository: GitRepository, channel: GitDecodeChannel, contracts: Iterable<ContractId>, options: ReconcileBatchOptions): Promise<readonly ReconcileBatchItem[]>;
+/** Remove only validated Contract reconciliation lock residue. */
+export declare function nukeReconcileLocks(repository: GitRepository): Promise<void>;
 export {};

package/build/src/git/reconcile.js

@@ -1,8 +1,9 @@
-import { access, mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { access, mkdir, readdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
 import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, GitPlumbingError, isKeiyakuOwnedRef, readRef, registeredWorktreePaths, runGit, writeCommit, worktreeGitDirectory, } from "./repository.js";
+import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, isKeiyakuOwnedRef, readRef, registeredWorktreePaths, writeCommit, worktreeGitDirectory, } from "./repository.js";
+import { GitPlumbingError, runGit } from "./process.js";
 import { contractLocator, contractPhysicalName, gitObjectIdForSnapshot, mintSnapshotId, } from "./identity.js";
 import { observeContractAt } from "./observe.js";
 import { acquireTargetPlacementFence, recoverTargetPlacement, } from "./target-placement.js";
@@ -206,7 +207,9 @@ async function reconcileHereWorkspaceRefs({ repository }, state, { effects, lag
         if (state.delivery === null)
             effects.push(await removeRef(repository, pin));
         else {
-            const integration = state.delivery.data.integration.snapshot;
+            const integration = state.currentIntegration?.snapshot;
+            if (integration === undefined)
+                return complete();
             const custodian = await snapshotCustodian(repository, integration);
             effects.push(await (custodian === null
                 ? await updateRef(repository, pin, integration)
@@ -216,7 +219,7 @@ async function reconcileHereWorkspaceRefs({ repository }, state, { effects, lag
     else if (state.bound) {
         effects.push(await (state.delivery === null
             ? await removeRef(repository, pin)
-            : await updateRef(repository, pin, state.delivery.data.integration.snapshot)));
+            : await updateRef(repository, pin, state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot)));
     }
     return complete(effects, lag);
 }
@@ -314,7 +317,7 @@ async function releaseTerminalCustody({ repository, state, expected, ref, pin, a
         return;
     }
     const tender = state.delivery.data.tenderSnapshot;
-    const integration = state.delivery.data.integration.snapshot;
+    const integration = state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot;
     const target = await targetCustodyForClaimedIntegration(repository, state, integration);
     if (sealedTree(expected, tender) === sealedTree(expected, integration) && target !== null) {
         effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
@@ -337,7 +340,7 @@ async function reconcileTerminalManagedWorktree({ repository, channel, hooks, re
     const expected = await terminalSealExpectations(channel, state);
     acc.effects.push(await updateRef(primary, ref, state.delivery?.data.tenderSnapshot ?? state.coordinates.start));
     if (state.delivery !== null) {
-        acc.effects.push(await updateRef(primary, pin, state.delivery.data.integration.snapshot));
+        acc.effects.push(await updateRef(primary, pin, state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot));
     }
     if (retainTerminalWorktree === true)
         return complete(acc.effects, acc.lag);
@@ -367,7 +370,7 @@ async function reconcileActiveManagedWorktree({ repository, hooks, retryHooks, p
     if (hookLag !== null)
         lag.push(hookLag);
     effects.push(await (state.delivery
-        ? await updateRef(repository, candidatePinRefFor(state.id), state.delivery.data.integration.snapshot)
+        ? await updateRef(repository, candidatePinRefFor(state.id), state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot)
         : await removeRef(repository, candidatePinRefFor(state.id))));
     return complete(effects, lag);
 }
@@ -463,3 +466,34 @@ export async function reconcileBatch(repository, channel, contracts, options) {
     }
     return items;
 }
+/** Remove only validated Contract reconciliation lock residue. */
+export async function nukeReconcileLocks(repository) {
+    const root = join(commonGitDirectory(repository), "keiyaku", "locks", "reconcile");
+    let first;
+    try {
+        first = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    let paths = [];
+    for (const directory of first) {
+        if (!/^[0-9a-f]{2}$/u.test(directory.name) || !directory.isDirectory() || directory.isSymbolicLink()) {
+            throw new Error(`reconciliation lock custody is invalid: ${resolve(root, directory.name)}`);
+        }
+        const nested = resolve(root, directory.name);
+        const files = await readdir(nested, { withFileTypes: true });
+        for (const file of files) {
+            if (!/^[0-9a-f]{62}\.sqlite$/u.test(file.name) || !file.isFile() || file.isSymbolicLink()) {
+                throw new Error(`reconciliation lock custody is invalid: ${resolve(nested, file.name)}`);
+            }
+            paths.push(resolve(nested, file.name));
+        }
+    }
+    for (const path of paths) {
+        const held = await acquireSqliteTransactionLock({ path, mode: "immediate" });
+        held.close();
+    }
+}

package/build/src/git/repository.d.ts

@@ -1,3 +1,4 @@
+import { type GitRepository } from "./process.js";
 import { type TreeChange, type TreeEntry } from "./tree.js";
 export type { TreeChange } from "./tree.js";
 export declare const GIT_REF = "refs/heads/keiyaku-state";
@@ -19,14 +20,6 @@ export type GitRefAssertion = Readonly<{
     readonly ref: string;
     readonly oid: GitOid;
 }>;
-export type GitRepository = Readonly<{
-    /** The invocation's effective working directory, including a caller -C worktree. */
-    readonly effectiveCwd: string;
-    /** The canonical primary worktree root for this repository. */
-    readonly primaryWorktree: string;
-    /** The canonical common Git directory pinned when this capability is created. */
-    readonly commonDirectory: string;
-}>;
 export type GitSnapshot = Readonly<{
     readonly commit: GitOid | null;
     readonly tree: GitOid | null;
@@ -36,41 +29,21 @@ export declare class NoGitWorldError extends Error {
     readonly path: string;
     constructor(path: string);
 }
-export declare class GitPlumbingError extends Error {
-    readonly stdout: Buffer;
-    readonly stderr: Buffer;
-    readonly status: number | null;
-    readonly pid: number | null;
-    constructor(input: Readonly<{
-        stdout?: string | Uint8Array;
-        stderr: string | Uint8Array;
-        status: number | null;
-        message: string;
-        pid?: number | null;
-    }>);
-}
 export type RegisteredWorktree = Readonly<{
     path: string;
     branch: string | null;
 }>;
 export declare function registeredWorktrees(repository: GitRepository): Promise<readonly RegisteredWorktree[]>;
 export declare function registeredWorktreePaths(repository: GitRepository): Promise<readonly string[]>;
-export declare function repositoryAt(cwd: string): Promise<GitRepository>;
+export declare function repositoryAt(cwd: string, gitPath?: string): Promise<GitRepository>;
 export declare function commonGitDirectory(repository: GitRepository): string;
 export declare function worktreeGitDirectory(repository: GitRepository, worktree: string): Promise<string>;
 export declare function worktreeRoot(repository: GitRepository): Promise<string>;
-export declare function runGit(repository: GitRepository, args: readonly string[], input?: string | Uint8Array): Promise<Buffer>;
-export declare function consumeGitStdout(repository: GitRepository, args: readonly string[], consume: (chunk: Buffer) => void): Promise<void>;
-export declare function runGitWithEnvironment(repository: GitRepository, args: readonly string[], input: string | Uint8Array | undefined, environment: NodeJS.ProcessEnv): Promise<Buffer>;
 export declare function readRef(repository: GitRepository, ref: string): Promise<GitOid | null>;
 export declare function readTreeEntries(repository: GitRepository, tree: GitOid): Promise<Map<string, TreeEntry>>;
 export declare function readGit(repository: GitRepository): Promise<GitSnapshot>;
 /** Read only the requested private Git paths from one immutable Git tree. */
 export declare function readGitPaths(repository: GitRepository, requestedPaths: readonly string[]): Promise<GitSnapshot>;
-/** Add paths from the same immutable Git tree without rereading its ref. */
-export declare function extendGitPaths(repository: GitRepository, snapshot: GitSnapshot, requestedPaths: readonly string[]): Promise<GitSnapshot>;
-/** Expand a targeted immutable snapshot to its complete already-pinned tree. */
-export declare function expandGitSnapshot(repository: GitRepository, snapshot: GitSnapshot): Promise<GitSnapshot>;
 export declare function writeBlob(repository: GitRepository, bytes: string | Uint8Array): Promise<GitOid>;
 export declare function readBlob(repository: GitRepository, oid: GitOid): Promise<Buffer>;
 /** Copy only the changed paths' tree ancestors, preserving untouched subtrees by object ID. */