@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/execution-result.d.ts

@@ -1,243 +0,0 @@
-import { type ContractHead, type ContractId, type JournalEntry } from "../core/facts/types.js";
-import type { ExecutionCleanup, ExecutionProgress, ExecutionStop } from "../protocol/progress.js";
-import { z } from "zod";
-export declare const mutationOperationSchema: z.ZodEnum<{
-    bind: "bind";
-    amend: "amend";
-    deliver: "deliver";
-    arc: "arc";
-    review: "review";
-    audit: "audit";
-    abandon: "abandon";
-}>;
-export type MutationOperation = z.infer<typeof mutationOperationSchema>;
-export type { ExecutionCleanup, ExecutionStop } from "../protocol/progress.js";
-export declare const executionCleanupSchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
-    kind: z.ZodLiteral<"verification-cleanup">;
-    contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-    snapshot: z.ZodOptional<z.ZodType<import("../core/facts/types.js").SnapshotId, unknown, z.core.$ZodTypeInternals<import("../core/facts/types.js").SnapshotId, unknown>>>;
-    failure: z.ZodType<Readonly<{
-        phase: "destroy";
-        name: string;
-        detail: import("../git/hooks.js").HookFailure;
-    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-        phase: "destroy";
-        name: string;
-        detail: import("../git/hooks.js").HookFailure;
-    }>, unknown>>;
-}, z.core.$strict>, z.ZodTransform<{
-    kind: "verification-cleanup";
-    contractId: ContractId;
-    failure: Readonly<{
-        phase: "destroy";
-        name: string;
-        detail: import("../git/hooks.js").HookFailure;
-    }>;
-} | {
-    snapshot: import("../core/facts/types.js").SnapshotId;
-    kind: "verification-cleanup";
-    contractId: ContractId;
-    failure: Readonly<{
-        phase: "destroy";
-        name: string;
-        detail: import("../git/hooks.js").HookFailure;
-    }>;
-}, {
-    kind: "verification-cleanup";
-    contractId: ContractId;
-    failure: Readonly<{
-        phase: "destroy";
-        name: string;
-        detail: import("../git/hooks.js").HookFailure;
-    }>;
-    snapshot?: import("../core/facts/types.js").SnapshotId | undefined;
-}>>, z.ZodPipe<z.ZodObject<{
-    kind: z.ZodLiteral<"worktree-leak">;
-    contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-    snapshot: z.ZodOptional<z.ZodType<import("../core/facts/types.js").SnapshotId, unknown, z.core.$ZodTypeInternals<import("../core/facts/types.js").SnapshotId, unknown>>>;
-    leak: z.ZodType<Readonly<{
-        path: string;
-        diagnostic: string;
-    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-        path: string;
-        diagnostic: string;
-    }>, unknown>>;
-}, z.core.$strict>, z.ZodTransform<{
-    kind: "worktree-leak";
-    contractId: ContractId;
-    leak: Readonly<{
-        path: string;
-        diagnostic: string;
-    }>;
-} | {
-    snapshot: import("../core/facts/types.js").SnapshotId;
-    kind: "worktree-leak";
-    contractId: ContractId;
-    leak: Readonly<{
-        path: string;
-        diagnostic: string;
-    }>;
-}, {
-    kind: "worktree-leak";
-    contractId: ContractId;
-    leak: Readonly<{
-        path: string;
-        diagnostic: string;
-    }>;
-    snapshot?: import("../core/facts/types.js").SnapshotId | undefined;
-}>>, z.ZodObject<{
-    kind: z.ZodLiteral<"private-state-seat-close">;
-    contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-    failure: z.ZodType<Readonly<{
-        kind: "private-state-seat-close-failed";
-        diagnostic: string;
-    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-        kind: "private-state-seat-close-failed";
-        diagnostic: string;
-    }>, unknown>>;
-}, z.core.$strict>]>;
-export declare const executionStopSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"execution-stopped">;
-    contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-    stage: z.ZodEnum<{
-        admission: "admission";
-        placement: "placement";
-        verification: "verification";
-        continuation: "continuation";
-        reconciliation: "reconciliation";
-        reintegration: "reintegration";
-    }>;
-    reason: z.ZodEnum<{
-        failed: "failed";
-        cancelled: "cancelled";
-    }>;
-    diagnostic: z.ZodString;
-}, z.core.$strict>;
-/** Confirmed facts accompanying an exceptional outcome; not a completed mutation answer. */
-export type ExecutionReceipt = Readonly<{
-    operation: MutationOperation;
-    contractId: ContractId;
-    head: ContractHead;
-    facts: readonly JournalEntry[];
-    cleanup: readonly ExecutionCleanup[];
-    executionStops: readonly ExecutionStop[];
-}>;
-export declare const executionReceiptSchema: z.ZodObject<{
-    operation: z.ZodEnum<{
-        bind: "bind";
-        amend: "amend";
-        deliver: "deliver";
-        arc: "arc";
-        review: "review";
-        audit: "audit";
-        abandon: "abandon";
-    }>;
-    contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-    head: z.ZodType<ContractHead, unknown, z.core.$ZodTypeInternals<ContractHead, unknown>>;
-    facts: z.ZodArray<z.ZodType<JournalEntry, unknown, z.core.$ZodTypeInternals<JournalEntry, unknown>>>;
-    cleanup: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
-        kind: z.ZodLiteral<"verification-cleanup">;
-        contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-        snapshot: z.ZodOptional<z.ZodType<import("../core/facts/types.js").SnapshotId, unknown, z.core.$ZodTypeInternals<import("../core/facts/types.js").SnapshotId, unknown>>>;
-        failure: z.ZodType<Readonly<{
-            phase: "destroy";
-            name: string;
-            detail: import("../git/hooks.js").HookFailure;
-        }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-            phase: "destroy";
-            name: string;
-            detail: import("../git/hooks.js").HookFailure;
-        }>, unknown>>;
-    }, z.core.$strict>, z.ZodTransform<{
-        kind: "verification-cleanup";
-        contractId: ContractId;
-        failure: Readonly<{
-            phase: "destroy";
-            name: string;
-            detail: import("../git/hooks.js").HookFailure;
-        }>;
-    } | {
-        snapshot: import("../core/facts/types.js").SnapshotId;
-        kind: "verification-cleanup";
-        contractId: ContractId;
-        failure: Readonly<{
-            phase: "destroy";
-            name: string;
-            detail: import("../git/hooks.js").HookFailure;
-        }>;
-    }, {
-        kind: "verification-cleanup";
-        contractId: ContractId;
-        failure: Readonly<{
-            phase: "destroy";
-            name: string;
-            detail: import("../git/hooks.js").HookFailure;
-        }>;
-        snapshot?: import("../core/facts/types.js").SnapshotId | undefined;
-    }>>, z.ZodPipe<z.ZodObject<{
-        kind: z.ZodLiteral<"worktree-leak">;
-        contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-        snapshot: z.ZodOptional<z.ZodType<import("../core/facts/types.js").SnapshotId, unknown, z.core.$ZodTypeInternals<import("../core/facts/types.js").SnapshotId, unknown>>>;
-        leak: z.ZodType<Readonly<{
-            path: string;
-            diagnostic: string;
-        }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-            path: string;
-            diagnostic: string;
-        }>, unknown>>;
-    }, z.core.$strict>, z.ZodTransform<{
-        kind: "worktree-leak";
-        contractId: ContractId;
-        leak: Readonly<{
-            path: string;
-            diagnostic: string;
-        }>;
-    } | {
-        snapshot: import("../core/facts/types.js").SnapshotId;
-        kind: "worktree-leak";
-        contractId: ContractId;
-        leak: Readonly<{
-            path: string;
-            diagnostic: string;
-        }>;
-    }, {
-        kind: "worktree-leak";
-        contractId: ContractId;
-        leak: Readonly<{
-            path: string;
-            diagnostic: string;
-        }>;
-        snapshot?: import("../core/facts/types.js").SnapshotId | undefined;
-    }>>, z.ZodObject<{
-        kind: z.ZodLiteral<"private-state-seat-close">;
-        contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-        failure: z.ZodType<Readonly<{
-            kind: "private-state-seat-close-failed";
-            diagnostic: string;
-        }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-            kind: "private-state-seat-close-failed";
-            diagnostic: string;
-        }>, unknown>>;
-    }, z.core.$strict>]>>;
-    executionStops: z.ZodArray<z.ZodObject<{
-        kind: z.ZodLiteral<"execution-stopped">;
-        contractId: z.ZodType<ContractId, unknown, z.core.$ZodTypeInternals<ContractId, unknown>>;
-        stage: z.ZodEnum<{
-            admission: "admission";
-            placement: "placement";
-            verification: "verification";
-            continuation: "continuation";
-            reconciliation: "reconciliation";
-            reintegration: "reintegration";
-        }>;
-        reason: z.ZodEnum<{
-            failed: "failed";
-            cancelled: "cancelled";
-        }>;
-        diagnostic: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare function receiptFromProgress(operation: MutationOperation, contractId: ContractId, progress: ExecutionProgress): ExecutionReceipt | undefined;
-/** Preserve the error category and the confirmed receipt instead of disguising failure as refusal. */
-export declare function withExecutionReceipt(error: unknown, receipt: ExecutionReceipt): Error;
-export declare function executionReceipt(error: unknown): ExecutionReceipt | undefined;

package/build/src/library/execution-result.js

@@ -1,101 +0,0 @@
-import { decodeJournalEntry } from "../core/facts/codec.js";
-import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { contractHead, contractId, snapshotId, } from "../core/facts/types.js";
-import { decodePrivateStateSeatCloseLag, decodeWorktreeLeak } from "../git/result-codec.js";
-import { decodeVerificationCleanupFailure } from "../protocol/result-codec.js";
-import { ownerSchema } from "./result-codec.js";
-import { z } from "zod";
-export const mutationOperationSchema = z.enum(["bind", "amend", "deliver", "review", "audit", "arc", "abandon"]);
-const contractSchema = ownerSchema((value) => {
-    if (typeof value !== "string")
-        throw new Error("expected contract identity");
-    return contractId(value);
-}, "expected contract identity");
-const snapshotSchema = ownerSchema((value) => {
-    if (typeof value !== "string")
-        throw new Error("expected snapshot identity");
-    return snapshotId(value);
-}, "expected snapshot identity");
-export const executionCleanupSchema = z.union([
-    z
-        .object({
-        kind: z.literal("verification-cleanup"),
-        contractId: contractSchema,
-        snapshot: snapshotSchema.optional(),
-        failure: ownerSchema(decodeVerificationCleanupFailure, "expected cleanup failure"),
-    })
-        .strict()
-        .transform(({ snapshot, ...rest }) => (snapshot === undefined ? rest : { ...rest, snapshot })),
-    z
-        .object({
-        kind: z.literal("worktree-leak"),
-        contractId: contractSchema,
-        snapshot: snapshotSchema.optional(),
-        leak: ownerSchema(decodeWorktreeLeak, "expected worktree leak"),
-    })
-        .strict()
-        .transform(({ snapshot, ...rest }) => (snapshot === undefined ? rest : { ...rest, snapshot })),
-    z
-        .object({
-        kind: z.literal("private-state-seat-close"),
-        contractId: contractSchema,
-        failure: ownerSchema(decodePrivateStateSeatCloseLag, "expected seat close failure"),
-    })
-        .strict(),
-]);
-export const executionStopSchema = z
-    .object({
-    kind: z.literal("execution-stopped"),
-    contractId: contractSchema,
-    stage: z.enum(["admission", "verification", "placement", "reintegration", "continuation", "reconciliation"]),
-    reason: z.enum(["cancelled", "failed"]),
-    diagnostic: z.string(),
-})
-    .strict();
-export const executionReceiptSchema = z
-    .object({
-    operation: mutationOperationSchema,
-    contractId: contractSchema,
-    head: ownerSchema((value) => {
-        if (typeof value !== "string")
-            throw new Error("expected contract head");
-        return contractHead(value);
-    }, "expected contract head"),
-    facts: z.array(ownerSchema(decodeJournalEntry, "expected journal entry")),
-    cleanup: z.array(executionCleanupSchema),
-    executionStops: z.array(executionStopSchema),
-})
-    .strict();
-export function receiptFromProgress(operation, contractId, progress) {
-    const head = progress.head(contractId);
-    if (head === undefined)
-        return undefined;
-    const snapshot = progress.snapshot();
-    return {
-        operation,
-        contractId,
-        head,
-        facts: snapshot.facts,
-        cleanup: snapshot.cleanup,
-        executionStops: snapshot.stops,
-    };
-}
-/** Preserve the error category and the confirmed receipt instead of disguising failure as refusal. */
-export function withExecutionReceipt(error, receipt) {
-    const original = error instanceof Error ? error : new Error(String(error));
-    const retained = Object.isExtensible(original)
-        ? original
-        : original instanceof AuthorityCorruptionError
-            ? new AuthorityCorruptionError(original.message, { cause: original })
-            : original instanceof TypeError
-                ? new TypeError(original.message, { cause: original })
-                : new Error(original.message, { cause: original });
-    Object.defineProperty(retained, "executionReceipt", { value: receipt, enumerable: true, configurable: true });
-    return retained;
-}
-export function executionReceipt(error) {
-    if (error === null || typeof error !== "object" || !("executionReceipt" in error))
-        return undefined;
-    const parsed = executionReceiptSchema.safeParse(error.executionReceipt);
-    return parsed.success ? parsed.data : undefined;
-}

package/build/src/library/execution.d.ts

@@ -1,8 +0,0 @@
-import type { ExecutionEvent, ExecutionObserver } from "../protocol/execution-observation.js";
-export type { ExecutionEvent } from "../protocol/execution-observation.js";
-export type ContractExecution<Result> = Readonly<{
-    progress: AsyncIterable<ExecutionEvent>;
-    result: Promise<Result>;
-}>;
-/** An eager invocation with one bounded, optional progress subscription. */
-export declare function startContractExecution<Result>(run: (observe: ExecutionObserver) => Promise<Result>): ContractExecution<Result>;

package/build/src/library/execution.js

@@ -1,102 +0,0 @@
-const MAX_EVENTS = 256;
-const MAX_BYTES = 128 * 1024;
-class BoundedExecutionProgress {
-    pending = [];
-    bytes = 0;
-    dropped = 0;
-    finished = false;
-    unsubscribed = false;
-    subscribed = false;
-    wake;
-    notify() {
-        const waiter = this.wake;
-        this.wake = undefined;
-        waiter?.();
-    }
-    publish = (event) => {
-        if (this.unsubscribed || this.finished)
-            return;
-        const size = Buffer.byteLength(JSON.stringify(event));
-        if (size > MAX_BYTES) {
-            this.dropped += 1;
-            this.notify();
-            return;
-        }
-        while (this.pending.length >= MAX_EVENTS || this.bytes + size > MAX_BYTES) {
-            this.bytes -= this.pending.shift().bytes;
-            this.dropped += 1;
-        }
-        this.pending.push({ event, bytes: size });
-        this.bytes += size;
-        this.notify();
-    };
-    close() {
-        this.finished = true;
-        this.notify();
-    }
-    iterable() {
-        return {
-            [Symbol.asyncIterator]: () => this.iterator(),
-        };
-    }
-    iterator() {
-        if (this.subscribed)
-            throw new Error("execution progress supports one subscription");
-        this.subscribed = true;
-        let reading = false;
-        return {
-            next: async () => {
-                if (reading)
-                    throw new Error("execution progress next calls must be serial");
-                reading = true;
-                try {
-                    for (;;) {
-                        const next = await this.next();
-                        if (next !== undefined)
-                            return next;
-                    }
-                }
-                finally {
-                    reading = false;
-                }
-            },
-            return: async () => {
-                this.unsubscribed = true;
-                this.pending.length = 0;
-                this.bytes = 0;
-                this.dropped = 0;
-                this.notify();
-                return { done: true, value: undefined };
-            },
-        };
-    }
-    async next() {
-        if (this.unsubscribed)
-            return { done: true, value: undefined };
-        if (this.dropped > 0) {
-            const count = this.dropped;
-            this.dropped = 0;
-            return { done: false, value: { kind: "progress-dropped", count } };
-        }
-        const pending = this.pending.shift();
-        if (pending !== undefined) {
-            this.bytes -= pending.bytes;
-            return { done: false, value: pending.event };
-        }
-        if (this.finished)
-            return { done: true, value: undefined };
-        await new Promise((resolve) => {
-            this.wake = resolve;
-        });
-        return undefined;
-    }
-}
-/** An eager invocation with one bounded, optional progress subscription. */
-export function startContractExecution(run) {
-    const observations = new BoundedExecutionProgress();
-    const result = Promise.resolve()
-        .then(() => run(observations.publish))
-        .finally(() => observations.close());
-    void result.catch(() => undefined);
-    return Object.freeze({ progress: observations.iterable(), result });
-}

package/build/src/library/fleet.d.ts

@@ -1,83 +0,0 @@
-/** @architectureCompositionRoot */
-import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt } from "../akuma/akuma.js";
-import { type ExecutionContext } from "../akuma/requests.js";
-import type { TellWaitObserver, WaitObserver } from "../akuma/fleet-execution.js";
-import { type DispatchAssociation } from "../dispatch/index.js";
-import { type Schema } from "../akuma/schema.js";
-import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
-import { type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellResult, type AkumaTellWaitResult, type AkumaWaitResult } from "../akuma/fleet-observation.js";
-export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
-    completion?: "any" | "all";
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}>;
-export type AkumaTellInput = AkumaAddressInput & Readonly<{
-    body: string;
-    initiator?: string;
-    signal?: AbortSignal;
-}>;
-export type AkumaTellWaitInput = AkumaAddressInput & Readonly<{
-    body: string;
-    timeoutMs: number;
-    schema?: Schema<unknown>;
-    interrupt?: boolean;
-    initiator?: string;
-    signal?: AbortSignal;
-    observe?: TellWaitObserver;
-}>;
-export type { TellResult, TellWake } from "../akuma/akuma.js";
-export type { CreatedTaskObservation } from "../task/created-observation.js";
-export type { DispatchAssociation } from "../dispatch/association.js";
-export type { AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaUnobserved, AkumaWaitResult, } from "../akuma/fleet-observation.js";
-export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
-    body: string;
-    initiator?: string;
-    signal?: AbortSignal;
-}>;
-export type AkumaKillInput = AkumaSetAddressInput & Readonly<{
-    signal?: AbortSignal;
-}>;
-export type AkumaInterruptResult = Readonly<{
-    id: AkumaStatus["id"];
-    receipt: InterruptReceipt;
-    observation: AkumaObservationStage;
-}>;
-export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
-    id?: string;
-    before?: number;
-    since?: number;
-    limit?: number;
-    last?: boolean;
-}>;
-export type AkumaHistoryResult = Readonly<{
-    kind: "history";
-    id: AkumaStatus["id"];
-    history: ActivityHistory;
-    contract: DispatchAssociation;
-}> | Readonly<{
-    kind: "exact";
-    id: AkumaStatus["id"];
-    outcome: OutcomeRow;
-    contract: DispatchAssociation;
-}> | Readonly<{
-    kind: "unknown-history";
-    id: AkumaStatus["id"];
-    historyId: string;
-    contract: DispatchAssociation;
-}> | Readonly<{
-    kind: "last";
-    id: AkumaStatus["id"];
-    answer: string;
-    contract: DispatchAssociation;
-}> | Readonly<{
-    kind: "no-answer";
-    id: AkumaStatus["id"];
-    contract: DispatchAssociation;
-}>;
-export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaObservation>;
-export declare function waitAkuma(input: AkumaWaitInput, execution?: ExecutionContext, observer?: WaitObserver): Promise<AkumaWaitResult>;
-export declare function killAkuma(input: AkumaKillInput, execution?: ExecutionContext): Promise<AkumaKillResult>;
-export declare function tellAkuma(input: AkumaTellInput, execution?: ExecutionContext): Promise<AkumaTellResult>;
-export declare function tellWaitAkuma(input: AkumaTellWaitInput, execution?: ExecutionContext): Promise<AkumaTellWaitResult>;
-export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
-export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;