@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import type { Offer } from "../core/facts/offer.js";
 import type { GitAdmissionSnapshot } from "./observe.js";
 import { type GitRefAssertion } from "./repository.js";
@@ -7,10 +8,11 @@ type Accepted = Readonly<{
     kind: "accepted";
     heads: Readonly<Record<string, ContractHead>>;
 }>;
-export type PublicationFailed = Readonly<{
-    kind: "publication-failed";
-    diagnostic: string;
-}>;
+export declare const publicationFailedSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"publication-failed">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>;
+export type PublicationFailed = z.infer<typeof publicationFailedSchema>;
 type Unknown = Readonly<{
     kind: "unknown";
 }>;

package/build/src/git/admission.js

@@ -1,9 +1,13 @@
+import { z } from "zod";
 import { decodeJournal, encodeEntry } from "../core/facts/codec.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, updateGitTreeFromFrozenDirectories, updateRefsAtomically, writeBlob, writeStateCommit, } from "./repository.js";
 import { contractJournalPath, contractJournalPaths, gitObjectIdForSnapshot, mintContractHead, mintSnapshotId, } from "./identity.js";
 import { validPath } from "./tree.js";
+export const publicationFailedSchema = z
+    .object({ kind: z.literal("publication-failed"), diagnostic: z.string() })
+    .strict();
 const CONTRACT_JOURNAL_PATH = /^contracts\/(?:active|terminal)\/[0-9a-f]{2}\/[0-9a-f]{2}\/[0-9a-f]{60}\.jsonl$/u;
 function assertAppendStructure(appends) {
     const seen = new Set();

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { type Settings } from "../settings.js";
 export type HookCommand = Readonly<{
     name: string;
@@ -8,42 +9,65 @@ export type WorktreeHooks = Readonly<{
     create: readonly HookCommand[];
     destroy: readonly HookCommand[];
 }>;
-export type HookFailure = Readonly<{
-    kind: "exit";
-    code: number;
-    stdout: string;
-    stderr: string;
-    truncated: boolean;
-}> | Readonly<{
-    kind: "timeout";
-    stdout?: string;
-    stderr?: string;
-    truncated?: boolean;
-}> | Readonly<{
-    kind: "spawn-error";
-    diagnostic: string;
-}> | Readonly<{
-    kind: "unknown-exit";
-    stdout?: string;
-    stderr?: string;
-    truncated?: boolean;
-}>;
-export type WorktreeHookLag = Readonly<{
-    kind: "worktree-hook-failed";
-    phase: HookPhase;
-    path: string;
-    command: number;
-    name: string;
-    failure: HookFailure;
-}>;
+export declare const hookFailureSchema: 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>]>;
+export type HookFailure = z.infer<typeof hookFailureSchema>;
+export declare const worktreeHookLagSchema: 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>;
+export type WorktreeHookLag = z.infer<typeof worktreeHookLagSchema>;
 export type HookPhase = "create" | "destroy";
-export type WorktreeHooksFromInput = Readonly<{
+type WorktreeHooksFromInput = Readonly<{
     settings: Settings;
 }>;
 export declare function worktreeHooksFrom(input: WorktreeHooksFromInput): WorktreeHooks;
 export declare function normalizedWorktreeHooks(value: unknown): WorktreeHooks;
 export declare const EMPTY_WORKTREE_HOOKS: WorktreeHooks;
-export declare function worktreeHooksOption(value: unknown): WorktreeHooks;
 export type HookCommandRun = Readonly<{
     kind: "ok";
 }> | Readonly<{
@@ -67,3 +91,4 @@ export type HookPhaseRun = Readonly<{
 }>;
 export declare function runCreateHooks(worktree: string, hooks: WorktreeHooks): Promise<HookPhaseRun>;
 export declare function runDestroyHooks(worktree: string, hooks: WorktreeHooks): Promise<HookPhaseRun>;
+export {};

package/build/src/git/hooks.js

@@ -1,5 +1,35 @@
+import { z } from "zod";
 import { runProcess } from "../runtime/proc/run.js";
 import { SettingsError } from "../settings.js";
+const hookOutputFields = {
+    stdout: z.string().optional(),
+    stderr: z.string().optional(),
+    truncated: z.boolean().optional(),
+};
+export const hookFailureSchema = z.union([
+    z
+        .object({
+        kind: z.literal("exit"),
+        code: z.number().int(),
+        stdout: z.string(),
+        stderr: z.string(),
+        truncated: z.boolean(),
+    })
+        .strict(),
+    z.object({ kind: z.literal("timeout"), ...hookOutputFields }).strict(),
+    z.object({ kind: z.literal("unknown-exit"), ...hookOutputFields }).strict(),
+    z.object({ kind: z.literal("spawn-error"), diagnostic: z.string().refine((value) => value.trim() !== "") }).strict(),
+]);
+export const worktreeHookLagSchema = z
+    .object({
+    kind: z.literal("worktree-hook-failed"),
+    phase: z.enum(["create", "destroy"]),
+    path: z.string().refine((value) => value.trim() !== ""),
+    command: z.number().int().nonnegative(),
+    name: z.string().refine((value) => value.trim() !== ""),
+    failure: hookFailureSchema,
+})
+    .strict();
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -80,9 +110,6 @@ export const EMPTY_WORKTREE_HOOKS = Object.freeze({
     create: Object.freeze([]),
     destroy: Object.freeze([]),
 });
-export function worktreeHooksOption(value) {
-    return value === undefined ? EMPTY_WORKTREE_HOOKS : normalizedWorktreeHooks(value);
-}
 function failedOutcome(outcome) {
     if (outcome.kind === "terminal") {
         return outcome.code === 0

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

@@ -1,4 +1,10 @@
+import { z } from "zod";
 import { type ChangeId, type ContractHead, type ContractId, type SnapshotId } from "../core/facts/types.js";
+export declare const contractIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
+export declare const snapshotIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+export declare const contractHeadSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ContractHead, string>>;
+export declare const changeIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ChangeId, string>>;
+export declare const mintedSnapshotInputSchema: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
 declare const gitObjectIdBrand: unique symbol;
 export type GitObjectId = string & {
     readonly [gitObjectIdBrand]: "GitObjectId";

package/build/src/git/identity.js

@@ -1,5 +1,52 @@
+import { z } from "zod";
 import { createHash } from "node:crypto";
 import { changeId, contractHead, contractId, snapshotId, } from "../core/facts/types.js";
+// Structural admission reuses the pure identity constructors; physical minting remains distinct.
+export const contractIdSchema = z.string().transform((value, context) => {
+    try {
+        return contractId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid contractId" });
+        return z.NEVER;
+    }
+});
+export const snapshotIdSchema = z.string().transform((value, context) => {
+    try {
+        return snapshotId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid snapshotId" });
+        return z.NEVER;
+    }
+});
+export const contractHeadSchema = z.string().transform((value, context) => {
+    try {
+        return contractHead(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid ContractHead" });
+        return z.NEVER;
+    }
+});
+export const changeIdSchema = z.string().transform((value, context) => {
+    try {
+        return changeId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid changeId" });
+        return z.NEVER;
+    }
+});
+export const mintedSnapshotInputSchema = z.string().transform((value, context) => {
+    try {
+        return mintSnapshotId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid mintSnapshotId" });
+        return z.NEVER;
+    }
+});
 const GIT_OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 function locator(value) {
     return createHash("sha256").update(value, "utf8").digest("hex");

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import type { Preparation } from "../core/decide.js";
 import type { ChangeId, ContractCoordinates, ContractId, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
@@ -6,18 +7,35 @@ import type { DeliveryCommitMetadata, TenderCapture } from "./tender.js";
 import { workspaceMergeStatePresent } from "./workspace.js";
 export { workspaceMergeStatePresent };
 type IntegrationTender = Pick<TenderCapture, "head" | "tree">;
-declare const REQUIRED_GIT: "2.38";
-export type IntegrationPreparationRefusal = Readonly<{
+export declare const integrationPreparationRefusalSchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"integration-failed">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
+    reason: z.ZodEnum<{
+        "not-based-on-target": "not-based-on-target";
+        "unrelated-histories": "unrelated-histories";
+        conflict: "conflict";
+    }>;
+    targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    conflictPaths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>, z.ZodTransform<{
     kind: "integration-failed";
     contractId: ContractId;
     reason: "not-based-on-target" | "unrelated-histories" | "conflict";
     targetHead: SnapshotId;
+} & {
     conflictPaths?: readonly string[];
-}> | Readonly<{
-    kind: "integration-unsupported";
+}, {
+    kind: "integration-failed";
     contractId: ContractId;
-    requiredGit: typeof REQUIRED_GIT;
-}>;
+    reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+    targetHead: SnapshotId;
+    conflictPaths?: readonly string[] | undefined;
+}>>, z.ZodObject<{
+    kind: z.ZodLiteral<"integration-unsupported">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
+    requiredGit: z.ZodLiteral<"2.38">;
+}, z.core.$strict>]>;
+export type IntegrationPreparationRefusal = z.infer<typeof integrationPreparationRefusalSchema>;
 export type IntegrationCoordinates = Readonly<{
     contractId: ContractId;
     coordinates: ContractCoordinates;
@@ -38,13 +56,13 @@ export declare function planIntegration(repository: GitRepository, input: Integr
     kind: "target-missing";
     contractId: ContractId;
 }> | IntegrationPreparationRefusal>>;
-export type DeliveryDiffScope = Readonly<{
-    filesChanged: number;
-    insertions: number;
-    deletions: number;
-    paths?: readonly string[];
-}>;
-/** Compute predecessor-to-candidate scope from the exact integration trees. */
+export declare const deliveryDiffScopeSchema: z.ZodObject<{
+    filesChanged: z.ZodNumber;
+    insertions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    paths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+type DeliveryDiffScope = z.infer<typeof deliveryDiffScopeSchema>;
 export declare function readDeliveryScope(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId, includePaths: boolean): Promise<DeliveryDiffScope>;
 /** Read a recorded integration pair's patch, or null when Git no longer has it. */
 export declare function readDeliveryDiff(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId): Promise<string | null>;

package/build/src/git/integration.js

@@ -1,3 +1,5 @@
+import { contractIdSchema, snapshotIdSchema } from "./identity.js";
+import { z } from "zod";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { gitObjectId, gitObjectIdForSnapshot, mintChangeId, mintSnapshotId } from "./identity.js";
 import { decodeGitNameOnly, decodeGitNumstat, readRef } from "./repository.js";
@@ -15,6 +17,28 @@ async function runAllowingNonzero(repository, args, input) {
         return { stdout: error.stdout, stderr: error.stderr, status: error.status };
     }
 }
+export const integrationPreparationRefusalSchema = z.union([
+    z
+        .object({
+        kind: z.literal("integration-failed"),
+        contractId: contractIdSchema,
+        reason: z.enum(["not-based-on-target", "unrelated-histories", "conflict"]),
+        targetHead: snapshotIdSchema,
+        conflictPaths: z
+            .array(z.string().refine((value) => value.trim() !== ""))
+            .readonly()
+            .optional(),
+    })
+        .strict()
+        .transform(({ conflictPaths, ...refusal }) => ({ ...refusal, ...(conflictPaths === undefined ? {} : { conflictPaths }) })),
+    z
+        .object({
+        kind: z.literal("integration-unsupported"),
+        contractId: contractIdSchema,
+        requiredGit: z.literal(REQUIRED_GIT),
+    })
+        .strict(),
+]);
 /** Mint the one worktree-content identity shared by review and delivery. */
 export async function worktreeChangeId(repository, input, tender) {
     const result = await runGitPipe(repository, [
@@ -290,7 +314,14 @@ async function deliverySnapshotAvailability(repository, predecessor, candidate)
     }
     return "available";
 }
-/** Compute predecessor-to-candidate scope from the exact integration trees. */
+export const deliveryDiffScopeSchema = z
+    .object({
+    filesChanged: z.number().int(),
+    insertions: z.number().int(),
+    deletions: z.number().int(),
+    paths: z.array(z.string()).readonly().optional(),
+})
+    .strict();
 export async function readDeliveryScope(repository, predecessor, candidate, includePaths) {
     const scope = decodeGitNumstat(await runGit(repository, [
         "diff",

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

@@ -1,4 +1,13 @@
 import type { WorldRoot } from "../world.js";
 import { type GitRepository } from "./process.js";
 import { type PrivateStateSeatOutcome } from "./private-state-seat.js";
-export declare function nukeGit(world: WorldRoot, gitPath?: string, options?: Readonly<Pick<GitRepository, "onPrivateStateSeatContention" | "onPrivateStateSeatClose">>): Promise<PrivateStateSeatOutcome<void>>;
+export declare class GitResetStopError extends Error {
+    constructor(message: string);
+}
+export declare function nukeGit(world: WorldRoot, gitPath?: string, options?: Readonly<Pick<GitRepository, "onPrivateStateSeatContention" | "onPrivateStateSeatClose">>, progress?: (confirmed: Readonly<{
+    refs?: number;
+    worktrees?: number;
+}>) => void): Promise<PrivateStateSeatOutcome<Readonly<{
+    refs: number;
+    worktrees: number;
+}>>>;

package/build/src/git/nuke.js

@@ -5,6 +5,12 @@ import { GitPlumbingError, runGit } from "./process.js";
 import { confirmPrivateStatePublication, withPrivateStatePublicationSeat, } from "./private-state-seat.js";
 import { CANDIDATE_PIN_REF_NAMESPACE, DELIVERY_REF_NAMESPACE, GIT_REF, NoGitWorldError, readRef, registeredWorktrees, repositoryAt, worktreeGitDirectory, } from "./repository.js";
 import { worktreePath } from "./workspace.js";
+export class GitResetStopError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitResetStopError";
+    }
+}
 async function managedCustody(repository) {
     const register = await readPlaceRegister(repository);
     return {
@@ -64,7 +70,7 @@ async function removeUnregisteredResidue(repository, entry) {
     if (!present)
         return true;
     if (!(await unregisteredResidueBelongsToRepository(repository, entry.path))) {
-        throw new Error(`managed Place path has foreign custody: ${entry.path}`);
+        throw new GitResetStopError(`managed Place path has foreign custody: ${entry.path}`);
     }
     await rm(entry.path, { recursive: true, force: true });
     try {
@@ -75,7 +81,7 @@ async function removeUnregisteredResidue(repository, entry) {
             return true;
         throw error;
     }
-    throw new Error(`managed Place worktree remains present: ${entry.path}`);
+    throw new GitResetStopError(`managed Place worktree remains present: ${entry.path}`);
 }
 async function removeManagedWorktree(repository, entry) {
     const registered = (await registeredWorktrees(repository)).find((candidate) => candidate.path === entry.path);
@@ -85,7 +91,7 @@ async function removeManagedWorktree(repository, entry) {
         return false;
     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}`);
+        throw new GitResetStopError(`managed Place worktree remains registered: ${entry.path}`);
     }
     try {
         await access(entry.path);
@@ -95,7 +101,7 @@ async function removeManagedWorktree(repository, entry) {
             return true;
         throw error;
     }
-    throw new Error(`managed Place worktree remains present: ${entry.path}`);
+    throw new GitResetStopError(`managed Place worktree remains present: ${entry.path}`);
 }
 async function deleteRefAt(repository, ref, expectedOid) {
     await runGit(repository, ["update-ref", "--no-deref", "-d", ref, expectedOid]);
@@ -114,9 +120,10 @@ async function deleteObservedStateRef(repository, expectedOid, seat) {
         confirmPrivateStatePublication(seat);
         return;
     }
-    throw new Error("state-ref deletion outcome is unknown");
+    throw new GitResetStopError("state-ref deletion outcome is unknown");
 }
-async function removeOwnedRefs(repository) {
+async function removeOwnedRefs(repository, onRemoved) {
+    let removed = 0;
     const roots = [DELIVERY_REF_NAMESPACE, CANDIDATE_PIN_REF_NAMESPACE];
     for (const root of roots) {
         const refs = (await runGit(repository, ["for-each-ref", "--format=%(refname)", root]))
@@ -125,34 +132,47 @@ async function removeOwnedRefs(repository) {
             .filter((ref) => ref.length > root.length && ref.startsWith(`${root}/`));
         for (const ref of refs) {
             const oid = await readRef(repository, ref);
-            if (oid !== null)
+            if (oid !== null) {
                 await deleteRefAt(repository, ref, oid);
+                removed += 1;
+                onRemoved?.(1);
+            }
         }
     }
+    return removed;
 }
-export async function nukeGit(world, gitPath = "git", options) {
+export async function nukeGit(world, gitPath = "git", options, progress) {
     let repository;
     try {
         repository = { ...(await repositoryAt(world, gitPath)), ...options };
     }
     catch (error) {
         if (error instanceof NoGitWorldError)
-            return { value: undefined };
+            return { value: { refs: 0, worktrees: 0 } };
         throw error;
     }
     return await withPlaceAuthorityFence(repository, async (placeFence) => {
         const custody = await managedCustody(repository);
         return await withPrivateStatePublicationSeat(repository, async (seat) => {
+            let refs = 0;
+            let worktrees = 0;
             const state = await readRef(repository, GIT_REF);
-            if (state !== null)
+            if (state !== null) {
                 await deleteObservedStateRef(repository, state, seat);
+                refs += 1;
+                progress?.({ refs: 1 });
+            }
             for (const entry of custody.entries) {
                 if (await removeManagedWorktree(repository, entry)) {
+                    worktrees += 1;
+                    progress?.({ worktrees: 1 });
                     await releaseManagedWorktrees(repository, [entry.contract], placeFence);
                 }
             }
             await nukeEmptyPlaceAuthority(repository, placeFence);
-            await removeOwnedRefs(repository);
+            const ownedRefs = await removeOwnedRefs(repository, (count) => progress?.({ refs: count }));
+            refs += ownedRefs;
+            return { refs, worktrees };
         });
     });
 }

package/build/src/git/observe.js

@@ -4,7 +4,7 @@ import { foldJournal } from "../core/facts/fold.js";
 import { contractJournalPath, contractJournalPaths, mintContractHead, mintSnapshotId, } from "./identity.js";
 import { isKeiyakuOwnedRef } from "./repository.js";
 import { GitPlumbingError, runGit } from "./process.js";
-import { readGitTreeSelection, withGitTargetedReadObservation, } from "./read-observation.js";
+import { readBlobResults, readGitTreeSelection, withGitTargetedReadObservation, } from "./read-observation.js";
 export async function observeDeliveryTargetAt(observation, state) {
     const target = state.coordinates.target;
     if (target === undefined)
@@ -288,20 +288,7 @@ export async function extendContractsForAdmissionAt(channel, observation, ids) {
     const missing = ids.filter((id) => !observation.decision.has(id));
     if (missing.length === 0)
         return observation;
-    const readBlobsAt = async (oids) => {
-        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;
-    };
+    const readBlobsAt = async (oids) => await readBlobResults(channel, oids);
     const snapshot = observation.admission.snapshot;
     if (snapshot.tree === null)
         return observation;

package/build/src/git/private-state-seat.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import type { GitRepository } from "./process.js";
 declare const privateStateSeat: unique symbol;
 /** Timed-out wait for the private-state publication seat. The holder and lock are unchanged. */
@@ -10,11 +11,11 @@ export type PrivateStatePublicationSeat = Readonly<{
     readonly [privateStateSeat]: true;
 }>;
 /** Post-confirmation failure to release the private-state publication seat. */
-export type PrivateStateSeatCloseLag = Readonly<{
-    kind: "private-state-seat-close-failed";
-    diagnostic: string;
-}>;
-/** Action result plus any confirmed-publication seat-close lag. */
+export declare const privateStateSeatCloseLagSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"private-state-seat-close-failed">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>;
+export type PrivateStateSeatCloseLag = z.infer<typeof privateStateSeatCloseLagSchema>;
 export type PrivateStateSeatOutcome<T> = Readonly<{
     value: T;
     closeLag?: PrivateStateSeatCloseLag;
@@ -25,8 +26,6 @@ export declare function privateStatePublicationSeatPath(repository: GitRepositor
 export declare function privateStateSeatCloseLag(error: unknown): PrivateStateSeatCloseLag;
 export declare function concatenatePrivateStateSeatClose(current: readonly PrivateStateSeatCloseLag[] | undefined, next: readonly PrivateStateSeatCloseLag[] | undefined): readonly PrivateStateSeatCloseLag[] | undefined;
 export declare function appendPrivateStateSeatClose(current: readonly PrivateStateSeatCloseLag[] | undefined, closeLag: PrivateStateSeatCloseLag): readonly PrivateStateSeatCloseLag[];
-/** Unwrap a seat outcome that has no typed lag surface; confirmed close lag throws. */
-export declare function requireClosedPrivateStateSeat<T>(outcome: PrivateStateSeatOutcome<T>): T;
 /** Unwrap a seat outcome through an owner-typed merge of confirmed close lag. */
 export declare function mergePrivateStateSeatClose<T>(outcome: PrivateStateSeatOutcome<T>, merge: (value: T, closeLag: PrivateStateSeatCloseLag) => T): T;
 export declare function isPrivateStateSeatContention(error: unknown): error is GitPrivateStateSeatContentionError;

package/build/src/git/private-state-seat.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { join } from "node:path";
 import { acquireSqliteTransactionLock, SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
@@ -14,6 +15,13 @@ export class GitPrivateStateSeatContentionError extends Error {
         this.name = "GitPrivateStateSeatContentionError";
     }
 }
+/** Post-confirmation failure to release the private-state publication seat. */
+export const privateStateSeatCloseLagSchema = z
+    .object({
+    kind: z.literal("private-state-seat-close-failed"),
+    diagnostic: z.string().refine((value) => value.trim() !== ""),
+})
+    .strict();
 /** Record a known or exact-read-back-proven private-root publication. */
 export function confirmPrivateStatePublication(seat) {
     confirmedPublications.add(seat);
@@ -34,12 +42,6 @@ export function concatenatePrivateStateSeatClose(current, next) {
 export function appendPrivateStateSeatClose(current, closeLag) {
     return current === undefined ? [closeLag] : [...current, closeLag];
 }
-/** Unwrap a seat outcome that has no typed lag surface; confirmed close lag throws. */
-export function requireClosedPrivateStateSeat(outcome) {
-    if (outcome.closeLag !== undefined)
-        throw new Error(outcome.closeLag.diagnostic);
-    return outcome.value;
-}
 /** Unwrap a seat outcome through an owner-typed merge of confirmed close lag. */
 export function mergePrivateStateSeatClose(outcome, merge) {
     return outcome.closeLag === undefined ? outcome.value : merge(outcome.value, outcome.closeLag);

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

@@ -36,7 +36,12 @@ export declare function readGitTreeSelection(channel: GitDecodeChannel, root: Gi
     paths: ReadonlyMap<string, TreeEntry>;
     directories: ReadonlyMap<string, ReadonlyMap<string, TreeEntry>>;
 }>>;
-export declare function withGitDecodeChannel<Value>(repository: GitRepository, consume: (channel: GitDecodeChannel) => Value | PromiseLike<Value>): Promise<Value>;
+export declare function withGitDecodeChannel<Value>(repository: GitRepository, consume: (channel: GitDecodeChannel) => Value | PromiseLike<Value>, onRetirementFailure?: (error: unknown) => void): Promise<Value>;
+/**
+ * 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 declare function readBlobResults(channel: GitDecodeChannel, oids: readonly GitOid[]): Promise<ReadonlyMap<GitOid, GitBlobResult>>;
 export declare function withGitReadObservation<Value>(repository: GitRepository, channel: GitDecodeChannel, consume: (observation: GitReadObservation) => Value | PromiseLike<Value>): Promise<Value>;
 export declare function withGitTargetedReadObservation<Value>(repository: GitRepository, channel: GitDecodeChannel, selection: GitTreeSelection, consume: (observation: GitReadObservation) => Value | PromiseLike<Value>): Promise<Value>;
 export {};