@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -6,6 +6,7 @@ import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readRef } from "./repositor
 import { GitPlumbingError } from "./process.js";
 const gitReadObservationBrand = Symbol("GitReadObservation");
 const gitDecodeChannelBrand = Symbol("GitDecodeChannel");
+const BATCH_RETIREMENT_GRACE_MS = 1_000;
 function streamCursor(stream) {
     const iterator = stream[Symbol.asyncIterator]();
     let buffer = Buffer.alloc(0);
@@ -64,13 +65,40 @@ function batchError(child, stderr, message, status) {
         pid: child.pid ?? null,
     });
 }
-async function closeBatchProcess(process, child, closed, spawnError, stderr) {
-    if (!child.stdin.destroyed)
-        child.stdin.end();
-    const outcome = await Promise.race([closed, process.terminationFailure]);
-    await process.waitTermination();
-    if (spawnError !== null || outcome.code !== 0) {
-        throw batchError(child, stderr, process.cancelled() ? "git process cancelled" : "git cat-file --batch did not close cleanly", outcome.code);
+async function closeBatchProcess(process, reader) {
+    const { child, closed, stderr } = reader;
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), BATCH_RETIREMENT_GRACE_MS);
+    });
+    try {
+        const drained = await Promise.race([reader.tail, process.terminationFailure, deadline]);
+        if (drained !== null && reader.status.failure !== null) {
+            await process.waitTermination();
+            return;
+        }
+        if (drained !== null && !child.stdin.destroyed)
+            child.stdin.end();
+        const outcome = drained === null ? null : await Promise.race([closed, process.terminationFailure, deadline]);
+        if (outcome === null) {
+            try {
+                await process.terminate(true);
+            }
+            finally {
+                child.stdin.destroy();
+                child.stdout.destroy();
+                child.stderr.destroy();
+                await process.waitTermination();
+            }
+            throw batchError(child, stderr, "decode-channel retirement exceeded its EOF close bound", child.exitCode);
+        }
+        await process.waitTermination();
+        if (reader.status.spawnError !== null || outcome.code !== 0) {
+            throw batchError(child, stderr, process.cancelled() ? "git process cancelled" : "git cat-file --batch did not close cleanly", outcome.code);
+        }
+    }
+    finally {
+        clearTimeout(timer);
     }
 }
 async function readBatchObject(cursor, oid) {
@@ -109,18 +137,17 @@ function batchObjectReader(repository) {
         child.once("close", (code, signal) => resolve({ code, signal }));
     });
     let tail = Promise.resolve();
-    let spawnError = null;
-    let failure = null;
+    const status = { spawnError: null, failure: null };
     child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
     child.on("error", (error) => {
-        spawnError = error;
+        status.spawnError = error;
     });
     child.stdin.on("error", (error) => {
-        spawnError ??= error;
+        status.spawnError ??= error;
     });
     const batch = async (oids) => {
-        if (failure !== null)
-            throw failure;
+        if (status.failure !== null)
+            throw status.failure;
         // Feed bounded request chunks while the single parser drains responses.
         const sending = writeBatchRequests(child, oids);
         const receiving = (async () => {
@@ -137,12 +164,12 @@ function batchObjectReader(repository) {
             child.stdin.destroy();
             child.stdout.destroy();
             await Promise.allSettled([sending, receiving]);
-            failure = batchError(child, stderr, process.cancelled() ? "git process cancelled" : String(error), null);
+            status.failure = batchError(child, stderr, process.cancelled() ? "git process cancelled" : String(error), null);
             await process.terminate(true);
             await closed;
             await process.waitTermination();
-            failure = batchError(child, stderr, process.cancelled() ? "git process cancelled" : error instanceof Error ? error.message : String(error), process.cancelled() ? null : child.exitCode);
-            throw failure;
+            status.failure = batchError(child, stderr, process.cancelled() ? "git process cancelled" : error instanceof Error ? error.message : String(error), process.cancelled() ? null : child.exitCode);
+            throw status.failure;
         }
     };
     const objects = async (oids) => {
@@ -159,12 +186,13 @@ function batchObjectReader(repository) {
         return new Map(await Promise.all(unique.map(async (oid) => [oid, await cache.get(oid)])));
     };
     const close = async () => {
-        await tail.catch(() => undefined);
-        if (failure !== null) {
-            await process.waitTermination();
-            return;
-        }
-        await closeBatchProcess(process, child, closed, spawnError, stderr);
+        await closeBatchProcess(process, {
+            child,
+            closed,
+            tail,
+            status,
+            stderr,
+        });
     };
     return { objects, close };
 }
@@ -290,7 +318,7 @@ async function readFormat(observation) {
         throw new AuthorityCorruptionError(`Git format is not current: ${GIT_FORMAT_PATH}`);
     }
 }
-export async function withGitDecodeChannel(repository, consume) {
+export async function withGitDecodeChannel(repository, consume, onRetirementFailure) {
     const transport = { reader: null };
     let active = true;
     const objectReader = () => (transport.reader ??= batchObjectReader(repository));
@@ -308,7 +336,7 @@ export async function withGitDecodeChannel(repository, consume) {
         result = await consume(channel);
     }
     catch (error) {
-        failure = error;
+        failure = { error };
     }
     active = false;
     try {
@@ -316,12 +344,33 @@ export async function withGitDecodeChannel(repository, consume) {
             await transport.reader.close();
     }
     catch (error) {
-        failure ??= error;
+        onRetirementFailure?.(error);
+        failure ??= { error };
     }
     if (failure !== undefined)
-        throw failure;
+        throw failure.error;
     return result;
 }
+/**
+ * Blob-only reads over a decode channel: a missing object stays missing, and a present
+ * non-blob object is authority corruption, never a silent skip.
+ */
+export async function readBlobResults(channel, oids) {
+    if (oids.length === 0)
+        return new Map();
+    const objects = await channel.readObjects(oids);
+    const blobs = new Map();
+    for (const [oid, object] of objects) {
+        if (object.kind === "missing")
+            blobs.set(oid, object);
+        else {
+            if (object.type !== "blob")
+                throw new AuthorityCorruptionError(`Git object is not a blob: ${oid}`);
+            blobs.set(oid, { kind: "present", bytes: object.bytes });
+        }
+    }
+    return blobs;
+}
 async function observeEpoch(repository, channel, selection, consume) {
     const commit = await readRef(repository, GIT_REF);
     let active = true;
@@ -339,23 +388,6 @@ async function observeEpoch(repository, channel, selection, consume) {
         }
         return await resolved;
     };
-    const readBlobResults = async (oids) => {
-        assertActive();
-        if (oids.length === 0)
-            return new Map();
-        const objects = await channel.readObjects(oids);
-        const blobs = new Map();
-        for (const [oid, object] of objects) {
-            if (object.kind === "missing")
-                blobs.set(oid, object);
-            else {
-                if (object.type !== "blob")
-                    throw new AuthorityCorruptionError(`Git object is not a blob: ${oid}`);
-                blobs.set(oid, { kind: "present", bytes: object.bytes });
-            }
-        }
-        return blobs;
-    };
     let result;
     let failure;
     try {
@@ -379,7 +411,10 @@ async function observeEpoch(repository, channel, selection, consume) {
             repository,
             snapshot,
             treeDirectories,
-            readBlobs: readBlobResults,
+            readBlobs: async (oids) => {
+                assertActive();
+                return await readBlobResults(channel, oids);
+            },
             resolveRef,
         };
         if (commit !== null)
@@ -387,11 +422,11 @@ async function observeEpoch(repository, channel, selection, consume) {
         result = await consume(observation);
     }
     catch (error) {
-        failure = error;
+        failure = { error };
     }
     active = false;
     if (failure !== undefined)
-        throw failure;
+        throw failure.error;
     return result;
 }
 export async function withGitReadObservation(repository, channel, consume) {

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

@@ -1,32 +1,60 @@
-import { type GitOid } from "./repository.js";
+import { z } from "zod";
 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";
-import { type WorktreeHookLag, type WorktreeHooks } from "./hooks.js";
-import type { UnsealedBytes } from "./terminal-seal.js";
-export type Effect = Readonly<{
+import { type WorktreeHooks } from "./hooks.js";
+export declare const reconcileEffectSchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"worktree">;
+    path: z.ZodString;
+    action: z.ZodEnum<{
+        created: "created";
+        unchanged: "unchanged";
+        removed: "removed";
+    }>;
+    before: z.ZodOptional<z.ZodUnknown>;
+    after: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>, z.ZodTransform<{
     kind: "worktree";
     path: string;
-    action: "created" | "removed" | "unchanged";
-}> | Readonly<{
+    action: "created" | "unchanged" | "removed";
+}, {
     kind: "worktree";
     path: string;
-    action: "followed";
-    before: SnapshotId;
-    after: SnapshotId;
-}> | Readonly<{
-    kind: "recovery-snapshot";
-    action: "created";
-    snapshot: SnapshotId;
-    retention: "ephemeral";
-}> | TargetCheckoutEffect | Readonly<{
-    kind: "ref";
-    name: string;
-    before: GitOid | null;
-    after: GitOid | null;
-    action: "created" | "updated" | "removed" | "unchanged";
-}>;
+    action: "created" | "unchanged" | "removed";
+    before?: unknown;
+    after?: unknown;
+}>>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree">;
+    path: z.ZodString;
+    action: z.ZodLiteral<"followed">;
+    before: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    after: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"recovery-snapshot">;
+    action: z.ZodLiteral<"created">;
+    snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    retention: z.ZodLiteral<"ephemeral">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"target-checkout">;
+    path: z.ZodString;
+    target: z.ZodString;
+    action: z.ZodEnum<{
+        followed: "followed";
+        recovered: "recovered";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"ref">;
+    name: z.ZodString;
+    before: z.ZodNullable<z.ZodString>;
+    after: z.ZodNullable<z.ZodString>;
+    action: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        unchanged: "unchanged";
+        removed: "removed";
+    }>;
+}, z.core.$strict>]>;
+export type Effect = z.infer<typeof reconcileEffectSchema>;
 type ReconcileInput = Readonly<{
     repository: GitRepository;
     channel: GitDecodeChannel;
@@ -35,25 +63,72 @@ type ReconcileInput = Readonly<{
     retryHooks: boolean;
     retainTerminalWorktree?: boolean;
     place?: string;
+    onPhysical?: (report: ReconcileResult) => void;
 }>;
-type WorktreeRetained = Readonly<{
-    kind: "worktree-retained";
-    path: string;
-}>;
-type WorktreeFollowRetained = Readonly<{
-    kind: "worktree-follow-retained";
-    path: string;
-    tender: SnapshotId;
-    head: SnapshotId;
-    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
-    paths?: readonly string[];
-}>;
-export type ReconcileFailure = Readonly<{
-    kind: "reconcile-failed";
-    stage: "observation" | "effect";
-    diagnostic: string;
-}>;
-export type ReconcileLag = WorktreeRetained | WorktreeFollowRetained | UnsealedBytes | TargetCheckoutLag | WorktreeHookLag | ReconcileFailure;
+export declare const gitReconcileLagSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-retained">;
+    path: z.ZodString;
+    diagnostic: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-follow-retained">;
+    path: z.ZodString;
+    tender: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    reason: z.ZodEnum<{
+        "head-moved": "head-moved";
+        "head-attached": "head-attached";
+        "operation-in-progress": "operation-in-progress";
+        "unsupported-parent-shape": "unsupported-parent-shape";
+    }>;
+    paths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unsealed-bytes">;
+    path: z.ZodString;
+    paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    head: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"target-checkout-retained">;
+    path: z.ZodString;
+    target: z.ZodString;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-hook-failed">;
+    phase: z.ZodEnum<{
+        destroy: "destroy";
+        create: "create";
+    }>;
+    path: z.ZodString;
+    command: z.ZodNumber;
+    name: z.ZodString;
+    failure: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"exit">;
+        code: z.ZodNumber;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        stdout: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodLiteral<"timeout">;
+    }, z.core.$strict>, z.ZodObject<{
+        stdout: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodLiteral<"unknown-exit">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"spawn-error">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reconcile-failed">;
+    stage: z.ZodEnum<{
+        observation: "observation";
+        effect: "effect";
+    }>;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>;
+export type ReconcileLag = z.infer<typeof gitReconcileLagSchema>;
 export type ReconcileResult = Readonly<{
     effects: readonly Effect[];
     lag: readonly ReconcileLag[];
@@ -81,6 +156,8 @@ export type ReconcileAccumulation = Readonly<{
         phase: "create" | "destroy";
         name: string;
     }[];
+    recordEffect(...effects: readonly Effect[]): void;
+    recordLag(...lag: readonly ReconcileLag[]): void;
 }>;
 export declare function reconcile(input: ReconcileInput): Promise<GitReconcileObservation>;
 /** Reconcile one retained dependent worktree under its normal per-Contract lock. */