@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/library/contract.js

@@ -8,18 +8,28 @@ import { observeRegion } from "./region.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { abandonOperation, amendOperation, arcOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
-import { withGitDecodeChannel } from "../git/read-observation.js";
+import { contractObservationOperation, contractsOperation, deliveryDiffOperation, deliveryOperation, stateOperation, } from "../protocol/operations.js";
+import { abandonOperation } from "../protocol/abandon.js";
+import { amendOperation } from "../protocol/amend.js";
+import { arcOperation } from "../protocol/arc.js";
+import { deliverOperation } from "../protocol/deliver.js";
+import { reviewOperation } from "../protocol/review.js";
+import { readDispatchesAt } from "../dispatch/index.js";
+import { mintSnapshotId } from "../git/identity.js";
+import { observeContractsForAdmissionInObservationAt } from "../git/observe.js";
+import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
 import { claimTaskHolderWithFence, releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection, } from "../settlement/holder.js";
 import { parseTaskId } from "../task/identity.js";
 import { reconcileInput, scopeForRepo } from "./repo.js";
+import { injectedBodyRequests, requestBodyDeliver, requestBodyReview, } from "../akuma/requests.js";
 import { auditContract } from "./audit.js";
 import { Delivery, deliveryHandle } from "./delivery.js";
 import { completeHolderMutation, completeMutation, } from "./mutation.js";
 import { completeReconcile } from "./reconcile.js";
 import { admitBindWithAppointment } from "./bind.js";
-import { KeiyakuRefused, requireAccepted } from "./refusal.js";
-export { KeiyakuRefused, KeiyakuRetry, } from "./refusal.js";
+import { KeiyakuRefused, KeiyakuRetry, requireAccepted, } from "./refusal.js";
+export { KeiyakuRefused, } from "./refusal.js";
+export { KeiyakuRetry };
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export { Delivery };
 function taskOption(value) {
@@ -38,6 +48,129 @@ function taskOption(value) {
 function completion(scope, channel, id, value, hooks) {
     return { scope, channel, contractId: id, value, hooks };
 }
+async function executeLocalDelivery(input) {
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const accepted = requireAccepted(await deliverOperation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(input.message === undefined ? {} : { message: input.message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        }));
+        return completeMutation({
+            ...completion(input.scope, channel, input.contractId, (delivery) => delivery, input.hooks),
+            accepted,
+        });
+    });
+}
+async function executeLocalReview(input) {
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const accepted = requireAccepted(await reviewOperation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
+            verdict: input.verdict,
+            ...(input.summary === undefined ? {} : { summary: input.summary }),
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+        }));
+        return completeMutation({
+            ...completion(input.scope, channel, input.contractId, (review) => review, input.hooks),
+            accepted,
+        });
+    });
+}
+function forwardedReceipt(outcome) {
+    if (outcome.kind === "failed") {
+        throw new Error(outcome.failure.kind === "failed"
+            ? outcome.failure.diagnostic
+            : `Unexpected Akuma target failure for deliver: ${outcome.failure.id}`);
+    }
+    return outcome.result;
+}
+function forwardedReviewReceipt(outcome) {
+    if (outcome.kind === "failed") {
+        throw new Error(outcome.failure.kind === "failed"
+            ? outcome.failure.diagnostic
+            : `Unexpected Akuma target failure for review: ${outcome.failure.id}`);
+    }
+    return outcome.result;
+}
+function requireForwardedDelivery(receipt) {
+    if (receipt.kind === "refused")
+        throw new KeiyakuRefused(receipt.refusal);
+    if (receipt.kind === "retry")
+        throw new KeiyakuRetry(receipt.reason);
+    return receipt.result;
+}
+function requireForwardedReview(receipt) {
+    if (receipt.kind === "refused")
+        throw new KeiyakuRefused(receipt.refusal);
+    if (receipt.kind === "retry")
+        throw new KeiyakuRetry(receipt.reason);
+    return receipt.result;
+}
+export async function executeForwardedDeliver(input) {
+    const id = contractId(input.contractId);
+    const actor = actorOption(input.requester).actor;
+    const message = optionalNonblank(input.message, "deliver message");
+    try {
+        const result = await executeLocalDelivery({
+            scope: scopeForRepo(input.repo),
+            contractId: id,
+            ...(actor === undefined ? {} : { actor }),
+            ...(message === undefined ? {} : { message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            hooks: input.hooks,
+        });
+        const delivery = result.facts.find((fact) => fact.kind === "deliver");
+        if (delivery === undefined)
+            throw new Error("accepted delivery is missing its journal fact");
+        return { result: { kind: "accepted", result }, deliveryFactId: delivery.entry };
+    }
+    catch (error) {
+        if (error instanceof KeiyakuRefused)
+            return { result: { kind: "refused", refusal: error.refusal } };
+        if (error instanceof KeiyakuRetry)
+            return { result: { kind: "retry", reason: error.reason } };
+        throw error;
+    }
+}
+export async function executeForwardedReview(input) {
+    const id = contractId(input.contractId);
+    const actor = actorOption(input.requester).actor;
+    if (input.verdict !== "satisfied" && input.verdict !== "unsatisfied") {
+        throw new TypeError("verdict must be satisfied or unsatisfied");
+    }
+    const summary = optionalNonblank(input.summary, "review summary");
+    try {
+        const result = await executeLocalReview({
+            scope: scopeForRepo(input.repo),
+            contractId: id,
+            ...(actor === undefined ? {} : { actor }),
+            verdict: input.verdict,
+            ...(summary === undefined ? {} : { summary }),
+            hooks: input.hooks,
+        });
+        const review = result.facts.find((fact) => fact.kind === "attestation");
+        if (review === undefined)
+            throw new Error("accepted review is missing its journal fact");
+        return { result: { kind: "accepted", result }, reviewFactId: review.entry };
+    }
+    catch (error) {
+        if (error instanceof KeiyakuRefused)
+            return { result: { kind: "refused", refusal: error.refusal } };
+        if (error instanceof KeiyakuRetry)
+            return { result: { kind: "retry", reason: error.reason } };
+        throw error;
+    }
+}
 export class KeiyakuHandle {
     id;
     scope;
@@ -53,6 +186,38 @@ export class KeiyakuHandle {
             contractId: this.id,
         }));
     }
+    async history() {
+        return withGitDecodeChannel(this.scope, (channel) => withGitReadObservation(this.scope, channel, async (observation) => {
+            const [journals, dispatches] = await Promise.all([
+                observeContractsForAdmissionInObservationAt(observation, [this.id]),
+                readDispatchesAt(observation),
+            ]);
+            const record = journals.journals.get(this.id);
+            if (record === undefined)
+                throw new Error(`missing requested contract observation: ${this.id}`);
+            if (record.state === null)
+                throw new KeiyakuRefused({ kind: "contract-missing", contractId: this.id });
+            const commit = observation.snapshot.commit;
+            if (commit === null)
+                throw new Error("contract history requires a keiyaku-state snapshot");
+            const recordedAt = (event) => (event.source === "journal" ? event.fact.at : event.dispatch.dispatchedAt);
+            const events = [
+                ...record.entries.map((fact) => ({ source: "journal", fact })),
+                ...dispatches
+                    .filter((dispatch) => dispatch.contractId === this.id)
+                    .map((dispatch) => ({ source: "dispatch", dispatch })),
+            ].sort((left, right) => {
+                const leftAt = recordedAt(left);
+                const rightAt = recordedAt(right);
+                if (leftAt !== rightAt)
+                    return leftAt < rightAt ? -1 : 1;
+                if (left.source !== right.source)
+                    return left.source === "journal" ? -1 : 1;
+                return 0;
+            });
+            return { id: this.id, state: mintSnapshotId(commit), events };
+        }));
+    }
     async guidance() {
         return withGitDecodeChannel(this.scope, async (channel) => {
             const observed = await contractObservationOperation({ scope: this.scope, channel, contractId: this.id });
@@ -74,12 +239,15 @@ export class KeiyakuHandle {
     async amend(input) {
         const values = requireInput(input, "amend input");
         const hooks = worktreeHooksOption(values.hooks);
-        const markdown = requireMarkdown(values.markdown);
+        const markdown = values.markdown === undefined ? undefined : requireMarkdown(values.markdown);
         const actor = actorOption(values.actor);
         const gates = values.gates === undefined ? undefined : normalizedGates(values.gates);
         const prerequisites = values.after === undefined
             ? undefined
             : normalizedList(values.after, "after", contractId);
+        if (markdown === undefined && gates === undefined && prerequisites === undefined) {
+            throw new TypeError("amend requires markdown, after, or gates");
+        }
         return withGitDecodeChannel(this.scope, async (channel) => {
             const accepted = requireAccepted(await amendOperation({
                 scope: this.scope,
@@ -87,8 +255,17 @@ export class KeiyakuHandle {
                 contractId: this.id,
                 ...actor,
                 deriveAmendment: (source) => {
-                    const document = decodeContractDocument(applyAmendDocument(markdown, decodeContractDocument(source.document.bytes)));
-                    const terms = contractTerms(document, gates ?? source.gates, prerequisites ?? source.after);
+                    const document = markdown === undefined
+                        ? decodeContractDocument(source.document.bytes)
+                        : decodeContractDocument(applyAmendDocument(markdown, decodeContractDocument(source.document.bytes)));
+                    const terms = markdown === undefined
+                        ? {
+                            document: source.document,
+                            segments: source.segments,
+                            gates: gates ?? source.gates,
+                            after: prerequisites ?? source.after,
+                        }
+                        : contractTerms(document, gates ?? source.gates, prerequisites ?? source.after);
                     return {
                         terms,
                         verification: documentDerivation(document, terms.gates, this.id).verification,
@@ -114,23 +291,27 @@ export class KeiyakuHandle {
         const includeDirty = optionalBoolean(values?.includeDirty, "includeDirty") ?? false;
         const actor = actorOption(values?.actor);
         const signal = optionalSignal(values?.signal);
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const accepted = requireAccepted(await deliverOperation({
+        const requests = injectedBodyRequests();
+        const result = requests === null
+            ? await executeLocalDelivery({
                 scope: this.scope,
-                channel,
                 contractId: this.id,
-                deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
                 ...actor,
                 ...(message === undefined ? {} : { message }),
                 requireBranchesToBeUpToDate,
                 includeDirty,
                 ...(signal === undefined ? {} : { signal }),
-            }));
-            return completeMutation({
-                ...completion(this.scope, channel, this.id, (delivery) => this.deliveryHandle(delivery), hooks),
-                accepted,
-            });
-        });
+                hooks,
+            })
+            : requireForwardedDelivery(forwardedReceipt(await requestBodyDeliver({
+                directory: requests,
+                repoRoot: this.scope.primaryWorktree,
+                contractId: this.id,
+                ...(message === undefined ? {} : { message }),
+                includeDirty,
+                ...(signal === undefined ? {} : { signal }),
+            })));
+        return { ...result, value: this.deliveryHandle(result.value) };
     }
     async review(input) {
         const values = requireInput(input, "review input");
@@ -140,19 +321,24 @@ export class KeiyakuHandle {
             throw new TypeError("verdict must be satisfied or unsatisfied");
         }
         const summary = optionalNonblank(values.summary, "review summary");
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const accepted = requireAccepted(await reviewOperation({
-                scope: this.scope,
-                channel,
+        const actor = actorOption(values.actor);
+        const requests = injectedBodyRequests();
+        if (requests !== null) {
+            return requireForwardedReview(forwardedReviewReceipt(await requestBodyReview({
+                directory: requests,
+                repoRoot: this.scope.primaryWorktree,
                 contractId: this.id,
                 verdict,
                 ...(summary === undefined ? {} : { summary }),
-                ...actorOption(values.actor),
-            }));
-            return completeMutation({
-                ...completion(this.scope, channel, this.id, (value) => value, hooks),
-                accepted,
-            });
+            })));
+        }
+        return await executeLocalReview({
+            scope: this.scope,
+            contractId: this.id,
+            ...actor,
+            verdict,
+            ...(summary === undefined ? {} : { summary }),
+            hooks,
         });
     }
     async abandon(input) {

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

@@ -1,5 +1,5 @@
 import type { SnapshotId } from "../core/facts/types.js";
-import type { DeliverValue } from "../protocol/operations.js";
+import type { DeliverValue } from "../protocol/deliver.js";
 declare class DeliveryHandle {
     private readonly readDiff;
     readonly verification?: DeliverValue["verification"];

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

@@ -1,23 +1,54 @@
 import { type ActivityHistory, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
 import type { ContractId } from "../core/facts/types.js";
+import type { TaskRow } from "../task/index.js";
+import type { WorldRoot } from "../world.js";
 import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
+import { type Repo } from "./repo.js";
+export type CreatedTaskObservation = Readonly<{
+    kind: "present";
+    rows: readonly TaskRow[];
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+export type DispatchAssociation = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "associated";
+    contractId: ContractId;
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+export type AkumaObservation = Readonly<{
+    status: AkumaStatus;
+    contract: DispatchAssociation;
+    createdTasks: CreatedTaskObservation;
+}>;
+export type AkumaObservationStage = (Readonly<{
+    kind: "observed";
+}> & AkumaObservation) | Readonly<{
+    kind: "unobserved";
+    diagnostic: string;
+}>;
+export type AkumaUnobserved = Readonly<{
+    id: AkumaStatus["id"];
+    diagnostic: string;
+}>;
 export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
 }>;
 export type AkumaWaitResult = Readonly<{
     completion: "any" | "all";
-    statuses: readonly AkumaStatusView[];
-}>;
-export type AkumaStatusView = Readonly<{
-    status: AkumaStatus;
-    contractId?: ContractId;
+    observations: readonly AkumaObservation[];
+    unobserved: readonly AkumaUnobserved[];
 }>;
 export type AkumaKillResult = Readonly<{
     results: readonly Readonly<{
         id: AkumaStatus["id"];
         evidence: KillEvidence;
-        observation: AkumaStatusView;
+        observation: AkumaObservationStage;
     }>[];
 }>;
 export type AkumaTellInput = AkumaAddressInput & Readonly<{
@@ -26,7 +57,7 @@ export type AkumaTellInput = AkumaAddressInput & Readonly<{
 export type AkumaTellResult = Readonly<{
     akuma: AkumaStatus["id"];
     tell: TellResult;
-    observation: AkumaStatusView;
+    observation: AkumaObservationStage;
 }>;
 export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
     body: string;
@@ -34,7 +65,7 @@ export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
 export type AkumaInterruptResult = Readonly<{
     id: AkumaStatus["id"];
     receipt: InterruptReceipt;
-    observation: AkumaStatusView;
+    observation: AkumaObservationStage;
 }>;
 export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
     before?: number;
@@ -46,20 +77,47 @@ export type AkumaHistoryResult = Readonly<{
     kind: "history";
     id: AkumaStatus["id"];
     history: ActivityHistory;
-    contractId?: ContractId;
+    contract: DispatchAssociation;
 }> | Readonly<{
     kind: "last";
     id: AkumaStatus["id"];
     answer: string;
-    contractId?: ContractId;
+    contract: DispatchAssociation;
 }> | Readonly<{
     kind: "no-answer";
     id: AkumaStatus["id"];
-    contractId?: ContractId;
+    contract: DispatchAssociation;
+}>;
+type WaitExecutionInput = Readonly<{
+    path: WorldRoot;
+    ids: readonly AkumaStatus["id"][];
+    completion: "any" | "all";
+    timeoutMs?: number;
+    repo?: Repo;
+    signal?: AbortSignal;
+}>;
+export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<AkumaWaitResult>;
+type TellExecutionInput = Readonly<{
+    path: WorldRoot;
+    id: AkumaStatus["id"];
+    body: string;
+    tellId?: string;
+    recordedAt?: string;
+    repo?: Repo;
+    signal?: AbortSignal;
+}>;
+export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
+type KillExecutionInput = Readonly<{
+    path: WorldRoot;
+    ids: readonly AkumaStatus["id"][];
+    repo?: Repo;
+    signal?: AbortSignal;
 }>;
-export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaStatusView>;
+export declare function executeKillAkuma(input: KillExecutionInput): Promise<AkumaKillResult>;
+export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaObservation>;
 export declare function waitAkuma(input: AkumaWaitInput): Promise<AkumaWaitResult>;
 export declare function killAkuma(input: AkumaSetAddressInput): Promise<AkumaKillResult>;
 export declare function tellAkuma(input: AkumaTellInput): Promise<AkumaTellResult>;
 export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
 export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;
+export {};