@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/git/reconcile.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { access, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
@@ -7,33 +7,51 @@ import { contractLocator, contractPhysicalName, gitObjectIdForSnapshot, mintSnap
 import { observeContractAt } from "./observe.js";
 import { acquireTargetPlacementFence, recoverTargetPlacement, } from "./target-placement.js";
 import { runCreateHooks, runDestroyHooks, } from "./hooks.js";
-import { deliveryWorktreePath } from "./workspace.js";
-import { orphanedScratchWorktrees } from "./scratch.js";
+import { worktreePath } from "./workspace.js";
+import { collectableScratchWorktrees } from "./scratch.js";
 import { terminalSealExpectations as decodeTerminalSealExpectations, terminalSealSnapshots, unsealedBytes, } from "./terminal-seal.js";
-function deliveryRefFor(contract) { return `${DELIVERY_REF_NAMESPACE}/${contractPhysicalName(contract)}`; }
-function candidatePinRefFor(contract) { return `${CANDIDATE_PIN_REF_NAMESPACE}/${contractPhysicalName(contract)}`; }
-function updateRef(repository, ref, desired) {
-    const before = readRef(repository, ref);
+const pathExists = (path) => access(path).then(() => true, () => false);
+function deliveryRefFor(contract) {
+    return `${DELIVERY_REF_NAMESPACE}/${contractPhysicalName(contract)}`;
+}
+function candidatePinRefFor(contract) {
+    return `${CANDIDATE_PIN_REF_NAMESPACE}/${contractPhysicalName(contract)}`;
+}
+function missingPlaceLag(repository) {
+    return {
+        kind: "reconcile-failed",
+        stage: "effect",
+        diagnostic: `managed Contract is unappointed: ${join(repository.commonDirectory, "keiyaku", "places.json")}`,
+    };
+}
+async function updateRef(repository, ref, desired) {
+    const before = await readRef(repository, ref);
     if (before === desired)
         return { kind: "ref", name: ref, action: "unchanged", before, after: desired };
-    runGit(repository, ["update-ref", "--no-deref", ref, gitObjectIdForSnapshot(desired), before ?? "0".repeat(desired.length)]);
+    await runGit(repository, [
+        "update-ref",
+        "--no-deref",
+        ref,
+        gitObjectIdForSnapshot(desired),
+        before ?? "0".repeat(desired.length),
+    ]);
     return { kind: "ref", name: ref, action: before === null ? "created" : "updated", before, after: desired };
 }
-function removeRef(repository, ref) {
-    const before = readRef(repository, ref);
+async function removeRef(repository, ref) {
+    const before = await readRef(repository, ref);
     if (before === null)
         return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
-    runGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
+    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
     return { kind: "ref", name: ref, action: "removed", before, after: null };
 }
-function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
-    const before = readRef(repository, ref);
+async function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
+    const before = await readRef(repository, ref);
     if (before === null)
         return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
-    if (readRef(repository, custodian) !== expectedCustodian) {
+    if (await readRef(repository, custodian) !== expectedCustodian) {
         return { kind: "ref", name: ref, action: "unchanged", before, after: before };
     }
-    runGit(repository, ["update-ref", "--stdin", "--no-deref"], [
+    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], [
         "start",
         `verify ${custodian} ${gitObjectIdForSnapshot(expectedCustodian)}`,
         `delete ${ref} ${before}`,
@@ -43,8 +61,8 @@ function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
     ].join("\n"));
     return { kind: "ref", name: ref, action: "removed", before, after: null };
 }
-function acquireWorktreeTopology(repository) {
-    return { paths: new Set(registeredWorktreePaths(repository)) };
+async function acquireWorktreeTopology(repository) {
+    return { paths: new Set(await registeredWorktreePaths(repository)) };
 }
 function fromPrimaryWorktree(repository) {
     return { ...repository, effectiveCwd: repository.primaryWorktree };
@@ -64,32 +82,36 @@ function reconcileLockPath(repository, contract) {
     const locator = contractLocator(contract);
     return join(commonGitDirectory(repository), "keiyaku", "locks", "reconcile", locator.slice(0, 2), `${locator.slice(2)}.sqlite`);
 }
-function worktree(repository, topology, path, desired) {
+async function worktree(repository, topology, path, desired) {
     const registered = topology.paths.has(path);
-    if (registered && existsSync(path))
+    if (registered && await pathExists(path))
         return { kind: "worktree", path, action: "unchanged" };
     if (registered) {
-        runGit(repository, ["worktree", "remove", path]);
+        await runGit(repository, ["worktree", "remove", path]);
         topology.paths.delete(path);
     }
-    if (existsSync(path))
+    if (await pathExists(path))
         throw new Error(`delivery worktree path is occupied: ${path}`);
-    mkdirSync(dirname(path), { recursive: true });
-    runGit(repository, ["worktree", "add", "--detach", path, gitObjectIdForSnapshot(desired)]);
+    await mkdir(dirname(path), { recursive: true });
+    await runGit(repository, ["worktree", "add", "--detach", path, gitObjectIdForSnapshot(desired)]);
     topology.paths.add(path);
     return { kind: "worktree", path, action: "created" };
 }
-function removeWorktree(repository, topology, path, force = false) {
+async function removeWorktree(repository, topology, path, force = false) {
     const registered = topology.paths.has(path);
-    if (!registered)
-        return { effect: { kind: "worktree", path, action: "unchanged" }, retained: false };
-    if (!existsSync(path)) {
-        runGit(repository, ["worktree", "remove", path]);
+    if (!registered) {
+        return {
+            effect: { kind: "worktree", path, action: "unchanged" },
+            retained: await pathExists(path),
+        };
+    }
+    if (!await pathExists(path)) {
+        await runGit(repository, ["worktree", "remove", path]);
         topology.paths.delete(path);
         return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
     }
     try {
-        runGit(repository, ["worktree", "remove", ...(force ? ["--force"] : []), path]);
+        await runGit(repository, ["worktree", "remove", ...(force ? ["--force"] : []), path]);
     }
     catch {
         return { effect: { kind: "worktree", path, action: "unchanged" }, retained: true };
@@ -97,19 +119,24 @@ function removeWorktree(repository, topology, path, force = false) {
     topology.paths.delete(path);
     return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
 }
-function removeOrphanedScratch(repository, topology, effects, lag) {
-    for (const path of orphanedScratchWorktrees(topology.paths)) {
-        const removal = removeWorktree(repository, topology, path, true);
-        effects.push(removal.effect);
-        if (removal.retained)
-            lag.push({ kind: "worktree-retained", path });
+async function removeCollectableScratch(repository, topology, effects, lag) {
+    for (const scratch of await collectableScratchWorktrees(topology.paths)) {
+        try {
+            const removal = await removeWorktree(repository, topology, scratch.path, true);
+            effects.push(removal.effect);
+            if (removal.retained)
+                lag.push({ kind: "worktree-retained", path: scratch.path });
+        }
+        finally {
+            scratch.release();
+        }
     }
 }
-function refRows(repository) {
-    const output = runGit(repository, [
+async function refRows(repository) {
+    const output = (await runGit(repository, [
         "for-each-ref",
         "--format=%(refname)%00%(objectname)",
-    ]).toString("utf8");
+    ])).toString("utf8");
     if (output.length === 0)
         return [];
     return output.trimEnd().split("\n").map((row) => {
@@ -119,12 +146,12 @@ function refRows(repository) {
         return { ref, oid };
     });
 }
-function snapshotCustodian(repository, snapshot) {
-    for (const row of refRows(repository)) {
+async function snapshotCustodian(repository, snapshot) {
+    for (const row of await refRows(repository)) {
         if (isKeiyakuOwnedRef(row.ref))
             continue;
         try {
-            runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(snapshot), row.oid]);
+            await runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(snapshot), row.oid]);
             return { ref: row.ref, oid: mintSnapshotId(row.oid) };
         }
         catch (error) {
@@ -149,7 +176,7 @@ async function reconcileTargetCheckouts(repository, state) {
     let result;
     let exceptional;
     try {
-        const recovered = recoverTargetPlacement(repository, state);
+        const recovered = await recoverTargetPlacement(repository, state);
         result = complete(recovered.effects, recovered.lag);
     }
     catch (error) {
@@ -173,23 +200,23 @@ async function reconcileTargetCheckouts(repository, state) {
         result = failed("effect", releaseFailure, result.effects, result.lag);
     return result;
 }
-function reconcileHereWorkspaceRefs({ repository }, state, { effects, lag }) {
+async function reconcileHereWorkspaceRefs({ repository }, state, { effects, lag }) {
     const pin = candidatePinRefFor(state.id);
     if (state.terminal) {
         if (state.delivery === null)
-            effects.push(removeRef(repository, pin));
+            effects.push(await removeRef(repository, pin));
         else {
             const integration = state.delivery.data.integration.snapshot;
-            const custodian = snapshotCustodian(repository, integration);
-            effects.push(custodian === null
-                ? updateRef(repository, pin, integration)
-                : removeRefWithCustody(repository, pin, custodian.ref, custodian.oid));
+            const custodian = await snapshotCustodian(repository, integration);
+            effects.push(await (custodian === null
+                ? await updateRef(repository, pin, integration)
+                : await removeRefWithCustody(repository, pin, custodian.ref, custodian.oid)));
         }
     }
     else if (state.bound) {
-        effects.push(state.delivery === null
-            ? removeRef(repository, pin)
-            : updateRef(repository, pin, state.delivery.data.integration.snapshot));
+        effects.push(await (state.delivery === null
+            ? await removeRef(repository, pin)
+            : await updateRef(repository, pin, state.delivery.data.integration.snapshot)));
     }
     return complete(effects, lag);
 }
@@ -204,26 +231,26 @@ async function terminalSealExpectations(channel, state) {
     return decodeTerminalSealExpectations(state, objects);
 }
 async function removeSealedTerminalWorktree({ repository, topology, path, expected, hooks, retryHooks, acc }) {
-    if (topology.paths.has(path) && existsSync(path)) {
-        const beforeHooks = unsealedBytes(repository, path, expected);
+    if (topology.paths.has(path) && await pathExists(path)) {
+        const beforeHooks = await unsealedBytes(repository, path, expected);
         if (beforeHooks !== null)
             return retainTerminalWorktree(path, beforeHooks, acc);
-        const hookLag = await runDestroyHooks(path, worktreeGitDirectory(repository, path), hooks, retryHooks);
+        const hookLag = await runDestroyHooks(path, await worktreeGitDirectory(repository, path), hooks, retryHooks);
         if (hookLag !== null)
             return retainTerminalWorktree(path, hookLag, acc);
-        const afterHooks = unsealedBytes(repository, path, expected);
+        const afterHooks = await unsealedBytes(repository, path, expected);
         if (afterHooks !== null)
             return retainTerminalWorktree(path, afterHooks, acc);
     }
-    const removal = removeWorktree(repository, topology, path, true);
+    const removal = await removeWorktree(repository, topology, path, true);
     if (removal.retained)
         return retainTerminalWorktree(path, { kind: "worktree-retained", path }, acc);
     acc.effects.push(removal.effect);
     return null;
 }
-function targetCustodyForClaimedIntegration(repository, state, integration) {
+async function targetCustodyForClaimedIntegration(repository, state, integration) {
     return state.terminal?.kind === "claimed" && state.coordinates.target !== undefined
-        && readRef(repository, state.coordinates.target) === integration
+        && await readRef(repository, state.coordinates.target) === integration
         ? { ref: state.coordinates.target, oid: integration }
         : null;
 }
@@ -233,56 +260,69 @@ function sealedTree(expected, snapshot) {
         throw new Error(`terminal seal tree was not resolved: ${snapshot}`);
     return tree;
 }
-function releaseTerminalCustody({ repository, state, expected, ref, pin, acc: { effects } }) {
+async function releaseTerminalCustody({ repository, state, expected, ref, pin, acc: { effects } }) {
     if (state.delivery === null) {
-        const custodian = snapshotCustodian(repository, state.coordinates.start);
+        const custodian = await snapshotCustodian(repository, state.coordinates.start);
         if (custodian !== null)
-            effects.push(removeRefWithCustody(repository, ref, custodian.ref, custodian.oid));
-        effects.push(removeRef(repository, pin));
+            effects.push(await removeRefWithCustody(repository, ref, custodian.ref, custodian.oid));
+        effects.push(await removeRef(repository, pin));
         return;
     }
     const tender = state.delivery.data.tenderSnapshot;
     const integration = state.delivery.data.integration.snapshot;
-    const target = targetCustodyForClaimedIntegration(repository, state, integration);
+    const target = await targetCustodyForClaimedIntegration(repository, state, integration);
     if (sealedTree(expected, tender) === sealedTree(expected, integration) && target !== null) {
-        effects.push(removeRefWithCustody(repository, ref, target.ref, target.oid));
-        effects.push(removeRefWithCustody(repository, pin, target.ref, target.oid));
+        effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
+        effects.push(await removeRefWithCustody(repository, pin, target.ref, target.oid));
     }
     else if (tender === integration) {
-        effects.push(removeRefWithCustody(repository, pin, ref, tender));
+        effects.push(await removeRefWithCustody(repository, pin, ref, tender));
     }
     else if (target !== null) {
-        effects.push(removeRefWithCustody(repository, pin, target.ref, target.oid));
+        effects.push(await removeRefWithCustody(repository, pin, target.ref, target.oid));
     }
 }
-async function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree }, state, topology, acc) {
+async function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree, place }, state, topology, acc) {
     const primary = fromPrimaryWorktree(repository);
     const ref = deliveryRefFor(state.id);
     const pin = candidatePinRefFor(state.id);
-    const path = deliveryWorktreePath(repository, state.id);
+    const path = place === undefined ? undefined : worktreePath(repository, place);
+    if (path === undefined)
+        return complete(acc.effects, acc.lag);
     const expected = await terminalSealExpectations(channel, state);
-    acc.effects.push(updateRef(primary, ref, state.delivery?.data.tenderSnapshot ?? state.coordinates.start));
-    if (state.delivery !== null)
-        acc.effects.push(updateRef(primary, pin, state.delivery.data.integration.snapshot));
+    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));
+    }
     if (retainTerminalWorktree === true)
         return complete(acc.effects, acc.lag);
-    const retained = await removeSealedTerminalWorktree({ repository: primary, topology, path, expected, hooks, retryHooks, acc });
+    const retained = await removeSealedTerminalWorktree({
+        repository: primary,
+        topology,
+        path,
+        expected,
+        hooks,
+        retryHooks,
+        acc,
+    });
     if (retained !== null)
         return retained;
-    releaseTerminalCustody({ repository: primary, state, expected, ref, pin, acc });
+    await releaseTerminalCustody({ repository: primary, state, expected, ref, pin, acc });
     return complete(acc.effects, acc.lag);
 }
-async function reconcileActiveManagedWorktree({ repository, hooks, retryHooks }, state, topology, { effects, lag }) {
-    const path = deliveryWorktreePath(repository, state.id);
+async function reconcileActiveManagedWorktree({ repository, hooks, retryHooks, place }, state, topology, { effects, lag }) {
+    if (place === undefined)
+        return complete(effects, [...lag, missingPlaceLag(repository)]);
+    const path = worktreePath(repository, place);
     const desired = state.delivery?.data.tenderSnapshot ?? state.coordinates.start;
-    effects.push(updateRef(repository, deliveryRefFor(state.id), desired));
-    effects.push(worktree(repository, topology, path, desired));
-    const hookLag = await runCreateHooks(path, worktreeGitDirectory(repository, path), hooks, retryHooks);
+    effects.push(await updateRef(repository, deliveryRefFor(state.id), desired));
+    effects.push(await worktree(repository, topology, path, desired));
+    const hookLag = await runCreateHooks(path, await worktreeGitDirectory(repository, path), hooks, retryHooks);
     if (hookLag !== null)
         lag.push(hookLag);
-    effects.push(state.delivery
-        ? updateRef(repository, candidatePinRefFor(state.id), state.delivery.data.integration.snapshot)
-        : removeRef(repository, candidatePinRefFor(state.id)));
+    effects.push(await (state.delivery
+        ? await updateRef(repository, candidatePinRefFor(state.id), state.delivery.data.integration.snapshot)
+        : await removeRef(repository, candidatePinRefFor(state.id))));
     return complete(effects, lag);
 }
 async function reconcileWithTopology(input, state, topology) {
@@ -290,14 +330,14 @@ async function reconcileWithTopology(input, state, topology) {
     const effects = [];
     const lag = [];
     try {
-        removeOrphanedScratch(repository, topology, effects, lag);
+        await removeCollectableScratch(repository, topology, effects, lag);
         if (!state)
             return complete(effects, lag);
         const targetCheckouts = await reconcileTargetCheckouts(repository, state);
         effects.push(...targetCheckouts.effects);
         lag.push(...targetCheckouts.lag);
         if (state.coordinates.workspace === "here")
-            return reconcileHereWorkspaceRefs(input, state, { effects, lag });
+            return await reconcileHereWorkspaceRefs(input, state, { effects, lag });
         if (state.terminal)
             return await reconcileTerminalManagedWorktree(input, state, topology, { effects, lag });
         return await reconcileActiveManagedWorktree(input, state, topology, { effects, lag });
@@ -334,7 +374,7 @@ export async function reconcile(input) {
     let exceptional;
     try {
         const state = (await observeContractAt(input.repository, input.channel, input.contractId)).state;
-        const topology = acquireWorktreeTopology(input.repository);
+        const topology = await acquireWorktreeTopology(input.repository);
         observation = {
             state,
             result: await reconcileWithTopology(input, state, topology),
@@ -359,18 +399,21 @@ export function reconcileObservationFailure(error) {
 export function reconcileEffectFailure(error, prior) {
     return failed("effect", error, prior?.effects, prior?.lag);
 }
-async function reconcileBatchItem(repository, channel, contract, options) {
-    const observation = await reconcile({ repository, channel, contractId: contract, ...options });
-    return {
-        contract,
-        state: observation.state,
-        result: observation.result,
-    };
-}
 /** Reconcile each discovered Contract through its own serialized, fresh observation. */
 export async function reconcileBatch(repository, channel, contracts, options) {
     const items = [];
-    for (const contract of contracts)
-        items.push(await reconcileBatchItem(repository, channel, contract, options));
+    for (const contract of contracts) {
+        const place = options.places?.get(contract);
+        const observation = await reconcile({
+            repository,
+            channel,
+            contractId: contract,
+            hooks: options.hooks,
+            retryHooks: options.retryHooks,
+            retainTerminalWorktree: options.retainTerminalWorktree,
+            ...(place === undefined ? {} : { place }),
+        });
+        items.push({ contract, state: observation.state, result: observation.result });
+    }
     return items;
 }

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

@@ -53,29 +53,30 @@ export type RegisteredWorktree = Readonly<{
     path: string;
     branch: string | null;
 }>;
-export declare function registeredWorktrees(repository: GitRepository): readonly RegisteredWorktree[];
-export declare function registeredWorktreePaths(repository: GitRepository): readonly string[];
-export declare function repositoryAt(cwd: string): GitRepository;
+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 commonGitDirectory(repository: GitRepository): string;
-export declare function worktreeGitDirectory(repository: GitRepository, worktree: string): string;
-export declare function worktreeRoot(repository: GitRepository): string;
-export declare function runGit(repository: GitRepository, args: readonly string[], input?: string | Uint8Array): Buffer;
-export declare function runGitWithEnvironment(repository: GitRepository, args: readonly string[], input: string | Uint8Array | undefined, environment: NodeJS.ProcessEnv): Buffer;
-export declare function readRef(repository: GitRepository, ref: string): GitOid | null;
-export declare function readTreeEntries(repository: GitRepository, tree: GitOid): Map<string, TreeEntry>;
-export declare function readGit(repository: GitRepository): GitSnapshot;
+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[]): GitSnapshot;
+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[]): GitSnapshot;
+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): GitSnapshot;
-export declare function writeBlob(repository: GitRepository, bytes: string | Uint8Array): GitOid;
-export declare function readBlob(repository: GitRepository, oid: GitOid): Buffer;
+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. */
-export declare function updateGitTree(repository: GitRepository, baseTree: GitOid | null, changes: ReadonlyMap<string, TreeChange>): GitOid;
+export declare function updateGitTree(repository: GitRepository, baseTree: GitOid | null, changes: ReadonlyMap<string, TreeChange>): Promise<GitOid>;
 /** Write a tree update from directory entries frozen with the admitted base tree. */
-export declare function updateGitTreeFromFrozenDirectories(repository: GitRepository, baseTree: GitOid | null, directories: ReadonlyMap<string, ReadonlyMap<string, TreeEntry>>, changes: ReadonlyMap<string, TreeChange>): GitOid;
+export declare function updateGitTreeFromFrozenDirectories(repository: GitRepository, baseTree: GitOid | null, directories: ReadonlyMap<string, ReadonlyMap<string, TreeEntry>>, changes: ReadonlyMap<string, TreeChange>): Promise<GitOid>;
 export declare function writeCommit(input: Readonly<{
     repository: GitRepository;
     tree: GitOid;
@@ -83,7 +84,7 @@ export declare function writeCommit(input: Readonly<{
     message?: string;
     actor?: string;
     at?: string;
-}>): GitOid;
+}>): Promise<GitOid>;
 export declare function updateRefsAtomically(repository: GitRepository, updates: readonly ({
     readonly ref: typeof GIT_REF;
     readonly newOid: GitOid;
@@ -92,4 +93,11 @@ export declare function updateRefsAtomically(repository: GitRepository, updates:
     readonly ref: string;
     readonly newOid: GitOid;
     readonly expectedOid: GitOid;
-})[], assertions?: readonly GitRefAssertion[]): RefPublication;
+})[], assertions?: readonly GitRefAssertion[]): Promise<RefPublication>;
+export type GitDiffStat = Readonly<{
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}>;
+export declare function decodeGitNumstat(output: Buffer): GitDiffStat;
+export declare function decodeGitNameOnly(output: Buffer): readonly string[];