@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/refusal.js

@@ -1,145 +1,57 @@
-import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { executionReceipt, executionReceiptSchema, withExecutionReceipt } from "./execution-result.js";
-import { contractId } from "../core/facts/types.js";
-import { decodeIntentRefusal, decodeProtocolTerminal } from "../protocol/result-codec.js";
-import { ownerSchema } from "./result-codec.js";
 import { z } from "zod";
-function decodeForkSourceRefusal(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed fork-source refusal");
-    const object = value;
-    if (Object.keys(object).some((key) => key !== "kind" && key !== "contractId"))
-        throw new Error("malformed fork-source refusal");
-    if (object.kind !== "fork-source-missing" &&
-        object.kind !== "fork-source-unavailable" &&
-        object.kind !== "fork-source-invalid" &&
-        object.kind !== "fork-source-moved")
-        throw new Error("malformed fork-source refusal");
-    if (typeof object.contractId !== "string")
-        throw new Error("malformed fork-source refusal");
-    return { kind: object.kind, contractId: contractId(object.contractId) };
-}
-function decodeNukeRefusal(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed nuke refusal");
-    const object = value;
-    if (object.kind === "nuke-confirmation-required") {
-        if (Object.keys(object).some((key) => key !== "kind" && key !== "world"))
-            throw new Error("malformed nuke refusal");
-        if (typeof object.world !== "string" || object.world.trim() === "")
-            throw new Error("malformed nuke refusal");
-        return { kind: "nuke-confirmation-required", world: object.world };
-    }
-    if (object.kind !== "nuke-confirmation-mismatch")
-        throw new Error("malformed nuke refusal");
-    if (Object.keys(object).some((key) => key !== "kind" && key !== "world" && key !== "confirmation"))
-        throw new Error("malformed nuke refusal");
-    if (typeof object.world !== "string" || object.world.trim() === "" || typeof object.confirmation !== "string")
-        throw new Error("malformed nuke refusal");
-    return { kind: "nuke-confirmation-mismatch", world: object.world, confirmation: object.confirmation };
-}
-export function decodeKeiyakuRefusal(value) {
-    try {
-        return decodeIntentRefusal(value);
-    }
-    catch {
-        try {
-            return decodeForkSourceRefusal(value);
-        }
-        catch {
-            return decodeNukeRefusal(value);
-        }
-    }
-}
-export const keiyakuRefusalSchema = ownerSchema(decodeKeiyakuRefusal, "expected keiyaku refusal");
-export const keiyakuRetryReasonSchema = ownerSchema(decodeProtocolTerminal, "expected keiyaku retry");
-export class KeiyakuRefused extends Error {
-    refusal;
-    kind = "refused";
-    constructor(refusal) {
-        super(`Keiyaku refused: ${refusal.kind}`);
-        this.refusal = refusal;
-        this.name = "KeiyakuRefused";
-    }
-    get code() {
-        return this.refusal.kind;
-    }
-}
-export class KeiyakuRetry extends Error {
-    reason;
-    kind = "retry";
-    constructor(reason) {
-        super(reason.kind === "publication-failed" ? reason.diagnostic : `Keiyaku retry required: ${reason.kind}`);
-        this.reason = reason;
-        this.name = "KeiyakuRetry";
-    }
-    get code() {
-        return this.reason.kind;
-    }
-}
-export function postAdmissionFailureCategory(error) {
-    return error instanceof AuthorityCorruptionError
-        ? "authority-corruption"
-        : error instanceof TypeError
-            ? "type-error"
-            : "error";
-}
-const contractLiveFailureSchema = z.union([
-    z
-        .object({
-        kind: z.literal("post-admission-failure"),
-        category: z.enum(["authority-corruption", "type-error", "error"]),
-        diagnostic: z.string(),
-        receipt: executionReceiptSchema,
-    })
-        .strict(),
-    z.object({ kind: z.literal("refused"), refusal: keiyakuRefusalSchema }).strict(),
-    z.object({ kind: z.literal("retry"), reason: keiyakuRetryReasonSchema }).strict(),
+import { contractIdSchema, intentRefusalSchema, activeContractRefusalSchema, bindRefusalSchema, amendRefusalSchema, deliverRefusalSchema, deliveryPreparationRefusalSchema, deliverConflictRefusalSchema, verificationDeclarationRefusalSchema, } from "../protocol/operations.js";
+import { targetInputRefusalSchema, forkSourceMovedRefusalSchema } from "../protocol/bind.js";
+import { protocolTerminalSchema } from "../protocol/run.js";
+import { worktreeMissingRefusalSchema, dirtyWorkspaceRefusalSchema } from "../git/tender.js";
+const forkSourceUnavailableSchema = z
+    .object({ kind: z.enum(["fork-source-missing", "fork-source-unavailable"]), contractId: contractIdSchema })
+    .strict();
+const forkSourceRefusalSchema = z.union([forkSourceUnavailableSchema, forkSourceMovedRefusalSchema]);
+export const nukeConfirmationRefusalSchema = z
+    .object({
+    kind: z.literal("nuke-confirmation-mismatch"),
+    world: z.string().refine((value) => value.trim() !== ""),
+    confirmation: z.string(),
+})
+    .strict();
+export const nukeConfirmationRequiredRefusalSchema = z
+    .object({ kind: z.literal("nuke-confirmation-required"), world: z.string().refine((value) => value.trim() !== "") })
+    .strict();
+export const keiyakuRefusalSchema = z.union([
+    intentRefusalSchema,
+    forkSourceRefusalSchema,
+    nukeConfirmationRefusalSchema,
+    nukeConfirmationRequiredRefusalSchema,
 ]);
-export function encodeContractLiveFailure(error) {
-    const receipt = executionReceipt(error);
-    if (receipt !== undefined)
-        return {
-            kind: "post-admission-failure",
-            category: postAdmissionFailureCategory(error),
-            diagnostic: error instanceof Error ? error.message : String(error),
-            receipt,
-        };
-    if (error instanceof KeiyakuRefused) {
-        return { kind: "refused", refusal: error.refusal };
-    }
-    if (error instanceof KeiyakuRetry) {
-        return { kind: "retry", reason: error.reason };
-    }
-    return null;
-}
-export function decodeContractLiveFailure(value) {
-    const parsed = contractLiveFailureSchema.safeParse(value);
-    if (!parsed.success)
-        return null;
-    if (parsed.data.kind === "post-admission-failure") {
-        const failure = parsed.data.category === "authority-corruption"
-            ? new AuthorityCorruptionError(parsed.data.diagnostic)
-            : parsed.data.category === "type-error"
-                ? new TypeError(parsed.data.diagnostic)
-                : new Error(parsed.data.diagnostic);
-        return withExecutionReceipt(failure, parsed.data.receipt);
-    }
-    return parsed.data.kind === "refused"
-        ? new KeiyakuRefused(decodeKeiyakuRefusal(parsed.data.refusal))
-        : new KeiyakuRetry(parsed.data.reason);
-}
-export function requireAccepted(result) {
-    if (result.kind === "refused")
-        throw new KeiyakuRefused(result.refusal);
-    if (result.kind === "retry")
-        throw new KeiyakuRetry(result.reason);
-    return result;
-}
-export function requireLeadingAdmission(result) {
-    if (result.kind === "refused")
-        throw new KeiyakuRefused(result.refusal);
-    if (result.kind === "retry")
-        throw new KeiyakuRetry(result.reason);
-    return result;
-}
+const forwardingRetrySchema = z
+    .object({ kind: z.literal("owner-reason-unavailable"), diagnostic: z.string() })
+    .strict();
+export const keiyakuRetryReasonSchema = z.union([protocolTerminalSchema, forwardingRetrySchema]);
+export const operationRetrySchemas = {
+    bind: protocolTerminalSchema,
+    amend: protocolTerminalSchema,
+    deliver: keiyakuRetryReasonSchema,
+    review: keiyakuRetryReasonSchema,
+    audit: keiyakuRetryReasonSchema,
+    arc: protocolTerminalSchema,
+    abandon: protocolTerminalSchema,
+};
+export const operationRefusalSchemas = {
+    bind: z.union([
+        bindRefusalSchema,
+        targetInputRefusalSchema,
+        forkSourceRefusalSchema,
+        verificationDeclarationRefusalSchema,
+    ]),
+    amend: z.union([amendRefusalSchema, verificationDeclarationRefusalSchema]),
+    deliver: z.union([
+        deliverRefusalSchema,
+        deliveryPreparationRefusalSchema,
+        deliverConflictRefusalSchema,
+        verificationDeclarationRefusalSchema,
+    ]),
+    review: z.union([activeContractRefusalSchema, worktreeMissingRefusalSchema, dirtyWorkspaceRefusalSchema]),
+    audit: z.union([deliverRefusalSchema, verificationDeclarationRefusalSchema]),
+    arc: activeContractRefusalSchema,
+    abandon: activeContractRefusalSchema,
+};

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

@@ -1,13 +1,21 @@
+import { z } from "zod";
 import type { ContractId } from "../core/facts/types.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import { type RepositoryScope } from "../protocol/operations.js";
-export type RegionOverlap = Readonly<{
-    contract: ContractId;
-    patterns: readonly Readonly<{
-        mine: string;
-        theirs: string;
-    }>[];
-}>;
+export declare const regionOverlapSchema: z.ZodObject<{
+    contract: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
+    patterns: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        mine: z.ZodString;
+        theirs: z.ZodString;
+        relation: z.ZodOptional<z.ZodEnum<{
+            same: "same";
+            "mine-within-theirs": "mine-within-theirs";
+            "theirs-within-mine": "theirs-within-mine";
+            intersect: "intersect";
+        }>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RegionOverlap = z.infer<typeof regionOverlapSchema>;
 export type RegionObservation = Readonly<{
     overlaps: readonly RegionOverlap[];
     overlapFailure?: never;

package/build/src/library/region.js

@@ -1,7 +1,23 @@
+import { z } from "zod";
+import { contractIdSchema } from "../protocol/operations.js";
 import { decodeContractDocument } from "../body/decode.js";
-import { regionsOverlap } from "../body/region.js";
+import { regionsOverlapWithRelation } from "../body/region.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { documentsOperationAt } from "../protocol/operations.js";
+export const regionOverlapSchema = z
+    .object({
+    contract: contractIdSchema,
+    patterns: z
+        .array(z
+        .object({
+        mine: z.string(),
+        theirs: z.string(),
+        relation: z.enum(["same", "mine-within-theirs", "theirs-within-mine", "intersect"]).optional(),
+    })
+        .strict())
+        .readonly(),
+})
+    .strict();
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -12,11 +28,15 @@ export async function observeRegion(scope, channel, self, mine) {
             if (peer.contract === self)
                 continue;
             try {
-                const pairs = regionsOverlap(mine, decodeContractDocument(peer.documentBytes).region);
+                const pairs = regionsOverlapWithRelation(mine, decodeContractDocument(peer.documentBytes).region);
                 if (pairs.length > 0)
                     overlaps.push({
                         contract: peer.contract,
-                        patterns: pairs.map(([minePattern, theirsPattern]) => ({ mine: minePattern, theirs: theirsPattern })),
+                        patterns: pairs.map(([minePattern, theirsPattern, relation]) => ({
+                            mine: minePattern,
+                            theirs: theirsPattern,
+                            relation,
+                        })),
                     });
             }
             catch (error) {

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

@@ -1,27 +1,17 @@
 import { type RepositoryScope } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
-import { type WorktreeHooks } from "./configuration.js";
-import { type RepoContractReconcileReport, type RepoReconcileReport } from "./reconcile.js";
 export { NoGitWorldError };
-export type { RepoContractReconcileReport, RepoReconcileReport };
+export type { RepoContractReconcileReport, RepoReconcileReport } from "./reconcile.js";
 export type RepoAtInput = Readonly<{
     path?: string;
     gitPath?: string;
 }>;
-export type ReconcileInput = Readonly<{
-    hooks?: WorktreeHooks;
-    retryHooks?: boolean;
-}>;
-export declare function reconcileInput(input: ReconcileInput | undefined): Readonly<{
-    hooks: WorktreeHooks;
-    retryHooks: boolean;
-}>;
+/** One Git world shared by its worktrees; it is coordinate proof and branch observation only. */
 export declare class Repo {
     readonly root: string;
     readonly cwd: string;
     private constructor();
     static at(input?: RepoAtInput): Promise<Repo>;
     currentBranch(): Promise<string | null>;
-    reconcile(input?: ReconcileInput): Promise<RepoReconcileReport>;
 }
 export declare function scopeForRepo(value: unknown): RepositoryScope;

package/build/src/library/repo.js

@@ -3,9 +3,6 @@ import { resolve } from "node:path";
 import { currentBranchOperation, scopeOperation } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 import { optionalNonblank, requireInput } from "./input.js";
-import { worktreeHooksOption } from "./configuration.js";
-import { withGitDecodeChannel } from "../git/read-observation.js";
-import { completeRepoReconcile } from "./reconcile.js";
 export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
 async function resolvePinnedScope(path, gitPath) {
@@ -14,16 +11,7 @@ async function resolvePinnedScope(path, gitPath) {
         ...(gitPath === undefined ? {} : { gitPath }),
     });
 }
-export function reconcileInput(input) {
-    const values = input === undefined ? undefined : requireInput(input, "reconcile input");
-    if (values?.retryHooks !== undefined && typeof values.retryHooks !== "boolean") {
-        throw new TypeError("retryHooks must be a boolean");
-    }
-    return {
-        hooks: worktreeHooksOption(values?.hooks),
-        retryHooks: values?.retryHooks ?? false,
-    };
-}
+/** One Git world shared by its worktrees; it is coordinate proof and branch observation only. */
 export class Repo {
     root;
     cwd;
@@ -39,15 +27,6 @@ export class Repo {
     async currentBranch() {
         return await currentBranchOperation({ scope: scopeForRepo(this) });
     }
-    async reconcile(input) {
-        const scope = scopeForRepo(this);
-        const options = reconcileInput(input);
-        return await withGitDecodeChannel(scope, (channel) => completeRepoReconcile({
-            scope,
-            channel,
-            ...options,
-        }));
-    }
 }
 export function scopeForRepo(value) {
     if (!(value instanceof Repo))

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

@@ -0,0 +1,121 @@
+import { type AskObserver } from "../akuma/akuma-selection-execution.js";
+import { type WaitObserver } from "../akuma/akuma-wait.js";
+import { type AkumaStatus } from "../akuma/akuma.js";
+import { type ActivityHistory, type OutcomeRow } from "../akuma/projection.js";
+import { type ExecutionContext } from "../akuma/requests.js";
+import { type Schema } from "../akuma/schema.js";
+import type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaTellResult, AkumaWaitResult } from "../akuma/selection-observation.js";
+import { type DispatchAssociation } from "../dispatch/index.js";
+import type { WorldRoot } from "../world.js";
+import { addressAkuma, addressAkumaSet, type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
+import { type Repo } from "./repo.js";
+type AddressedAkuma = Awaited<ReturnType<typeof addressAkuma>>;
+type AddressedAkumaSet = Awaited<ReturnType<typeof addressAkumaSet>>;
+type UncheckedSelectionAddress = Parameters<typeof addressAkuma>[0];
+type SelectionWaitMode = Readonly<{
+    completion: "any" | "all";
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    repo?: Repo;
+}>;
+/**
+ * The one typed selection seam captured per execution. Selector resolution is
+ * bound once: local execution addresses and proves birth in this process, while
+ * a forwarded operation resolves coordinates only because the serving parent
+ * owns the target and its admission probes. Each verb's local or forwarded
+ * ability is likewise chosen once here, so no operation repeats a route branch.
+ */
+export type SelectionSeam = Readonly<{
+    addressOne(input: UncheckedSelectionAddress): Promise<AddressedAkuma>;
+    addressSet(input: UncheckedSelectionAddress): Promise<AddressedAkumaSet>;
+    wait(addressed: AddressedAkumaSet, mode: SelectionWaitMode, observer?: WaitObserver): Promise<AkumaWaitResult>;
+    kill(addressed: AddressedAkumaSet, signal?: AbortSignal): Promise<AkumaKillResult>;
+    tell(addressed: AddressedAkuma, input: AkumaTellInput, signal?: AbortSignal): Promise<AkumaTellResult>;
+    ask<T>(addressed: AddressedAkuma, input: AkumaAskInput<T>, signal?: AbortSignal): Promise<AkumaAskResult<T>>;
+}>;
+export declare function selectionSeam(execution: ExecutionContext): SelectionSeam;
+export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
+    completion?: "any" | "all";
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /** The existing optional live-observation seam, validated here like Ask's. */
+    observe?: WaitObserver;
+}>;
+export type AkumaTellInput = AkumaAddressInput & Readonly<{
+    body: string;
+    interrupt?: boolean;
+    initiator?: string;
+    signal?: AbortSignal;
+}>;
+export type AkumaAskInput<T = string> = AkumaAddressInput & Readonly<{
+    body: string;
+    timeoutMs?: number;
+    schema?: Schema<T>;
+    interrupt?: boolean;
+    initiator?: string;
+    signal?: AbortSignal;
+    observe?: AskObserver;
+}>;
+export type { TellResult, TellWake } from "../akuma/body.js";
+export type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaUnobserved, AkumaWaitResult, } from "../akuma/selection-observation.js";
+export type { DispatchAssociation } from "../dispatch/association.js";
+export type { CreatedTaskObservation } from "../task/created-observation.js";
+export type AkumaKillInput = AkumaSetAddressInput & Readonly<{
+    signal?: AbortSignal;
+}>;
+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 & Readonly<{
+    path: WorldRoot;
+}>): Promise<AkumaObservation>;
+export declare function waitAkuma(input: AkumaWaitInput & Readonly<{
+    path: WorldRoot;
+}>, execution?: ExecutionContext): Promise<AkumaWaitResult>;
+export declare function waitAkumaOn(seam: SelectionSeam, input: AkumaWaitInput & Readonly<{
+    path: WorldRoot;
+}>): Promise<AkumaWaitResult>;
+export declare function killAkumaOn(seam: SelectionSeam, input: AkumaKillInput & Readonly<{
+    path: WorldRoot;
+}>): Promise<AkumaKillResult>;
+export declare function tellAkuma(input: AkumaTellInput & Readonly<{
+    path: WorldRoot;
+}>, execution?: ExecutionContext): Promise<AkumaTellResult>;
+export declare function tellAkumaOn(seam: SelectionSeam, input: AkumaTellInput & Readonly<{
+    path: WorldRoot;
+}>): Promise<AkumaTellResult>;
+export declare function askAkumaOn<T = string>(seam: SelectionSeam, input: AkumaAskInput<T> & Readonly<{
+    path: WorldRoot;
+}>): Promise<AkumaAskResult<T>>;
+export declare function historyAkuma(input: AkumaHistoryInput & Readonly<{
+    path: WorldRoot;
+}>): Promise<AkumaHistoryResult>;