@astrosheep/keiyaku 4.5.7 → 4.5.9

package/build/src/akuma/request-rendezvous.js

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { access, readFile } from "node:fs/promises";
+import { abortableDelay } from "./abort.js";
+import { atomicJson, decodeReceiptEnvelope, receiptPath, requestPath } from "./request-wire.js";
+const POLL_MS = 100;
+export class AkumaBodyRequestError extends Error {
+    action;
+    outcome;
+    diagnostic;
+    kind = "akuma-body-request";
+    constructor(action, outcome, diagnostic) {
+        super(`${action} ${outcome === "voided" ? "failed" : "refused"}: ${diagnostic}`);
+        this.action = action;
+        this.outcome = outcome;
+        this.diagnostic = diagnostic;
+        this.name = "AkumaBodyRequestError";
+    }
+}
+function throwVoidedRequestFailure(action, evidence, failure, decodeFailure) {
+    const ownerFailure = decodeVoidedOwnerFailure(failure, decodeFailure);
+    if (ownerFailure !== null)
+        throw ownerFailure;
+    throw new AkumaBodyRequestError(action, "voided", evidence);
+}
+function decodeVoidedOwnerFailure(failure, decodeFailure) {
+    if (failure === undefined || decodeFailure === undefined)
+        return null;
+    try {
+        return decodeFailure(failure);
+    }
+    catch {
+        return null;
+    }
+}
+function withRequestMetadata(response, id, action) {
+    Object.defineProperties(response, {
+        requestId: { value: id, enumerable: false },
+        action: { value: action, enumerable: false },
+    });
+    return response;
+}
+/** Generic rendezvous only: operation owners supply their own request and result codecs. */
+export async function requestBodyCommand(input) {
+    const id = input.id ?? randomUUID();
+    input.signal?.throwIfAborted();
+    const transportId = randomUUID();
+    await atomicJson(requestPath(input.directory, transportId), {
+        id,
+        action: input.command.action,
+        payload: input.command.encodeRequest(input.value),
+    });
+    const path = receiptPath(input.directory, transportId);
+    for (;;) {
+        try {
+            const receipt = decodeReceiptEnvelope(await readFile(path, "utf8"), id, input.command.action);
+            if (receipt === null)
+                throw new Error(`Akuma body request ${id} has an invalid receipt`);
+            if (receipt.state === "refused")
+                throw new AkumaBodyRequestError(receipt.action, "refused", receipt.diagnostic);
+            if (receipt.state === "voided") {
+                throwVoidedRequestFailure(receipt.action, receipt.evidence, receipt.failure, input.command.decodeFailure);
+            }
+            if ("reference" in receipt) {
+                let reference;
+                try {
+                    reference = input.command.decodeReference(receipt.reference);
+                }
+                catch (error) {
+                    const diagnostic = error instanceof Error ? error.message : String(error);
+                    throw new Error(`transport integrity: request ${id} action ${input.command.action} returned an invalid durable reference: ${diagnostic}`);
+                }
+                return withRequestMetadata({
+                    kind: "reference",
+                    reference,
+                }, id, input.command.action);
+            }
+            if (receipt.outcome.kind === "failed") {
+                const failure = receipt.outcome.failure;
+                throw new Error(failure.kind === "failed" ? failure.diagnostic : `Akuma ${failure.id} was not born`);
+            }
+            let result;
+            try {
+                result = input.command.decodeResult(receipt.outcome.result);
+            }
+            catch (error) {
+                const diagnostic = error instanceof Error ? error.message : String(error);
+                throw new Error(`transport integrity: request ${id} action ${input.command.action} returned an invalid live result: ${diagnostic}`);
+            }
+            return withRequestMetadata({ kind: "returned", result }, id, input.command.action);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (!(await access(input.directory).then(() => true, () => false))) {
+            throw new AkumaBodyRequestError(input.command.action, "voided", "parent request channel closed before a receipt");
+        }
+        await abortableDelay(POLL_MS, input.signal);
+    }
+}

package/build/src/akuma/request-serve.d.ts

@@ -1,77 +1,17 @@
-import { type KillEvidence, type RequestFact } from "./heart/index.js";
-import { type AkuId } from "./identity.js";
-import { type StructuralRequestClaim } from "./request-wire.js";
-import { type TaskMutationRequest } from "../task/mutation.js";
-import { BodyRequestPump as LifecycleBodyRequestPump, type RequestChildLaunch as LifecycleRequestChildLaunch, type PumpInput as LifecyclePumpInput } from "./request-lifecycle.js";
+import { type ErasedRequestCommand, type RequestEnvelope } from "./request-wire.js";
+import { BodyRequestPump as LifecycleBodyRequestPump, type PumpInput as LifecyclePumpInput } from "./request-lifecycle.js";
 export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
-export type RequestChildLaunch = LifecycleRequestChildLaunch;
-type UpstreamCall = Readonly<{
-    signal: AbortSignal;
-}>;
-type RequesterCall = UpstreamCall & Readonly<{
-    requester: AkuId;
-}>;
-type ContractCall = RequesterCall & Readonly<{
-    repoRoot: string;
-    contractId: string;
-}>;
-export type UpstreamExecutionPort = Readonly<{
-    wait(input: UpstreamCall & Readonly<{
-        targets: readonly AkuId[];
-        completion: "any" | "all";
-        timeoutMs?: number;
-    }>): Promise<unknown>;
-    tell(input: UpstreamCall & Readonly<{
-        target: AkuId;
-        body: string;
-        tellId: string;
-        recordedAt: string;
-    }>): Promise<unknown>;
-    kill(input: Readonly<{
-        targets: readonly AkuId[];
-        signal: AbortSignal;
-    }>): Promise<Readonly<{
-        result: unknown;
-        service: readonly Readonly<{
-            id: AkuId;
-            evidence: KillEvidence;
-        }>[];
-    }>>;
-    deliver(input: ContractCall & Readonly<{
-        message?: string;
-        includeDirty: boolean;
-        materializeConflict: boolean;
-    }>): Promise<Readonly<{
-        result: unknown;
-        deliveryFactId?: string;
-    }>>;
-    review(input: ContractCall & Readonly<{
-        verdict: "satisfied" | "unsatisfied";
-        summary?: string;
-    }>): Promise<Readonly<{
-        result: unknown;
-        reviewFactId?: string;
-    }>>;
-    task(input: RequesterCall & Readonly<{
-        world: string;
-        request: TaskMutationRequest;
-    }>): Promise<unknown>;
-}>;
 type PumpInput = Omit<LifecyclePumpInput, "upstream"> & Readonly<{
-    upstream?: UpstreamExecutionPort;
+    upstream?: unknown;
+    commands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
 export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
     directory: string;
     transportId: string;
-    claim: StructuralRequestClaim;
+    claim: RequestEnvelope;
     admissionOpen(): boolean;
 }>;
-export type UpstreamFact = Exclude<Extract<RequestFact, {
-    state: "admitted";
-}>, Extract<RequestFact, {
-    action: "akuma.call";
-}>>;
-export declare function serveRequest(input: ServeInput): Promise<void>;
+export declare function serveRequest(input: ServeInput): Promise<boolean>;
 export declare class BodyRequestPump extends LifecycleBodyRequestPump {
     static open(input: PumpInput): Promise<BodyRequestPump>;
 }

package/build/src/akuma/request-serve.js

@@ -1,252 +1,124 @@
-import { admitRequest, isRequestInputConflict, readRequest, refuseRequest, reserveRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
-import { worldRootForAkumaPaths } from "./identity.js";
-import { publishAkuma } from "./publication.js";
-import { atomicJson, canonicalAkuId, decodeRecipe, receiptPath, } from "./request-wire.js";
-import { isTaskMutationAction } from "../task/mutation.js";
-import { executeRequest } from "./request-execution.js";
+import { admitRequest, isRequestInputConflict, readRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
+import { atomicJson, receiptPath, } from "./request-wire.js";
 import { BodyRequestPump as LifecycleBodyRequestPump, } from "./request-lifecycle.js";
 export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function isTask(value) {
-    return isTaskMutationAction(value.action);
-}
-function refusalRecipe(value) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        const recipe = value;
-        if (Array.isArray(recipe.allowed))
-            return recipe;
-        return { ...recipe, allowed: [] };
-    }
-    return { allowed: [] };
-}
-function acceptedReceipt(fact, service) {
-    return {
-        id: fact.id,
-        action: fact.action,
-        state: fact.state,
-        reference: service.action === "contract.deliver"
+async function projectCommandReceipt(input, fact, command, outcome, failure) {
+    const receipt = fact.state === "refused"
+        ? { id: fact.id, action: fact.action, state: "refused", diagnostic: fact.diagnostic }
+        : fact.state === "voided"
             ? {
-                kind: "accepted-reference",
-                repoRoot: service.repoRoot,
-                contractId: service.contractId,
-                deliveryFactId: service.deliveryFactId,
+                id: fact.id,
+                action: fact.action,
+                state: "voided",
+                evidence: fact.evidence,
+                ...(failure === undefined ? {} : { failure }),
             }
-            : {
-                kind: "accepted-reference",
-                repoRoot: service.repoRoot,
-                contractId: service.contractId,
-                reviewFactId: service.reviewFactId,
-            },
-    };
-}
-function receiptFor(fact) {
-    if (fact.state === "refused") {
-        return { id: fact.id, action: fact.action, state: fact.state, diagnostic: fact.diagnostic };
-    }
-    if (fact.state === "voided") {
-        return { id: fact.id, action: fact.action, state: fact.state, evidence: fact.evidence };
-    }
-    if (fact.action === "akuma.call" && fact.state === "served") {
-        return { id: fact.id, action: fact.action, state: fact.state, child: fact.child };
-    }
-    if (fact.state !== "served")
-        return null;
-    if (fact.action === "contract.deliver") {
-        return acceptedReceipt(fact, fact.service);
-    }
-    if (fact.action === "contract.review") {
-        return acceptedReceipt(fact, fact.service);
-    }
-    if (isTask(fact)) {
-        return {
-            id: fact.id,
-            action: fact.action,
-            state: fact.state,
-            reference: { kind: "served-reference", action: fact.action },
-        };
-    }
-    return null;
-}
-async function projectReceipt(directory, transportId, fact, outcome) {
-    const receipt = outcome === undefined
-        ? receiptFor(fact)
-        : fact.action === "akuma.call"
-            ? null
-            : { id: fact.id, action: fact.action, state: "served", outcome };
+            : outcome === undefined
+                ? "serviceJson" in fact
+                    ? {
+                        id: fact.id,
+                        action: fact.action,
+                        state: "served",
+                        reference: command.projectServiceJson(fact.serviceJson),
+                    }
+                    : "child" in fact
+                        ? {
+                            id: fact.id,
+                            action: fact.action,
+                            state: "served",
+                            reference: command.projectChild(fact.child),
+                        }
+                        : null
+                : { id: fact.id, action: fact.action, state: "served", outcome };
     if (receipt === null)
         return;
     try {
-        await atomicJson(receiptPath(directory, transportId), receipt);
+        await atomicJson(receiptPath(input.directory, input.transportId), receipt);
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
 }
-async function refuseInvalidCall(input) {
+async function serveCommand(input, command) {
+    const request = command.resolve(input.claim.payload);
+    if (request === null)
+        return false;
     let fact = await admitRequest(input.paths, {
-        ...input.claim,
-        recipe: refusalRecipe(input.claim.recipe),
+        id: input.claim.id,
+        action: input.claim.action,
+        payloadJson: request.payloadJson,
         admittedAt: input.now(),
+        permitted: request.isPermitted(input.parent.allowed),
     });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
-    }
-    fact = await refuseRequest(input.paths, input.claim.id, "invalid akuma.call recipe");
-    await projectReceipt(input.directory, input.transportId, fact);
-}
-async function serveCall(input) {
-    input.signal.throwIfAborted();
-    if (!input.admissionOpen())
-        return;
-    const recipe = decodeRecipe(input.claim.recipe);
-    if (recipe === null) {
-        await refuseInvalidCall(input);
-        return;
-    }
-    let fact = await admitRequest(input.paths, { ...input.claim, recipe, admittedAt: input.now() });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
+    if (fact.state !== "admitted") {
+        await projectCommandReceipt(input, fact, request);
+        return true;
     }
     if (!input.admissionOpen()) {
-        fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
-    }
-    if (fact.action !== "akuma.call" || fact.state !== "admitted") {
-        throw new Error(`Akuma request ${fact.id} cannot be replayed from ${fact.state}`);
-    }
-    const request = fact;
-    const world = worldRootForAkumaPaths(input.paths);
-    if (request.world !== world) {
-        fact = await refuseRequest(input.paths, request.id, `request world ${request.world} does not match ${world}`);
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
+        fact = await voidRequest(input.paths, fact.id, "body closed request admission");
+        await projectCommandReceipt(input, fact, request);
+        return true;
     }
     try {
-        const published = await publishAkuma({
-            worldPath: world,
-            archetype: request.archetype,
+        const served = await request.execute({
+            id: fact.id,
+            admittedAt: fact.admittedAt,
+            requester: fact.requester,
             signal: input.signal,
-            launch: async (allocated) => {
-                if (!input.admissionOpen())
-                    throw new Error("body closed request admission");
-                fact = await reserveRequest(input.paths, request.id, allocated.id);
-                return await input.spawn({
-                    paths: allocated.paths,
-                    seed: {
-                        id: allocated.id,
-                        archetype: allocated.archetype,
-                        ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
-                        provider: request.recipe.provider,
-                        options: request.recipe.options,
-                        ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
-                        allowed: request.recipe.allowed,
-                        cwd: request.cwd ?? input.parent.cwd,
-                        origin: {
-                            kind: "request",
-                            parent: input.parent.id,
-                            requestId: request.id,
-                        },
-                    },
-                    initialBody: request.body,
-                });
-            },
+            upstream: input.upstream,
+            paths: input.paths,
+            parent: input.parent,
+            spawn: input.spawn,
+            admissionOpen: input.admissionOpen,
         });
-        fact = await serveChildRequest(input.paths, request.id, published.id);
+        fact =
+            "child" in served
+                ? await serveChildRequest(input.paths, fact.id, served.child)
+                : await serveUpstreamRequest(input.paths, fact.id, served.serviceJson);
+        await projectCommandReceipt(input, fact, request, { kind: "returned", result: served.result });
     }
     catch (error) {
-        const current = await readRequest(input.paths, request.id);
+        const failure = encodedFailure(request, error);
+        const current = await readRequest(input.paths, fact.id);
         if (current === null)
             throw error;
         fact =
             current.state === "admitted" || current.state === "reserved"
-                ? await voidRequest(input.paths, request.id, diagnostic(error))
+                ? await voidRequest(input.paths, fact.id, diagnostic(error))
                 : current;
+        await projectCommandReceipt(input, fact, request, undefined, failure);
     }
-    await projectReceipt(input.directory, input.transportId, fact);
-}
-function failure(error) {
-    const value = error !== null && typeof error === "object" ? error : null;
-    if (value?.kind === "akuma-not-born") {
-        const id = canonicalAkuId(value.id);
-        if (id !== null)
-            return { kind: "akuma-not-born", id };
-    }
-    return { kind: "failed", diagnostic: diagnostic(error) };
+    return true;
 }
-function pendingService(request) {
-    if (request.action === "akuma.wait")
-        return { action: request.action };
-    if (request.action === "akuma.tell") {
-        return { action: request.action, target: request.target, tellId: request.id };
-    }
-    return request.action === "akuma.kill" ? { action: request.action, results: [] } : undefined;
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
 }
-async function serveUpstream(input) {
-    input.signal.throwIfAborted();
-    let fact = await admitRequest(input.paths, {
-        ...input.claim,
-        admittedAt: input.now(),
-    });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
-    }
-    if (fact.state === "served") {
-        await projectReceipt(input.directory, input.transportId, fact, {
-            kind: "failed",
-            failure: {
-                kind: "failed",
-                diagnostic: "served request receipt is no longer available",
-            },
-        });
-        return;
-    }
-    if (!input.admissionOpen()) {
-        fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
-    }
-    if (fact.state !== "admitted" || fact.action === "akuma.call") {
-        throw new Error(`Akuma request ${fact.id} cannot be served from ${fact.state}`);
-    }
-    const request = fact;
-    let outcome;
-    let service = pendingService(request);
+function encodedFailure(request, error) {
     try {
-        const served = await executeRequest(input, request);
-        outcome = { kind: "returned", result: served.result };
-        if (served.service !== undefined)
-            service = served.service;
+        const failure = request.encodeFailure(error);
+        return failure === null ? undefined : failure;
     }
-    catch (error) {
-        outcome = { kind: "failed", failure: failure(error) };
-        fact = await voidRequest(input.paths, request.id, "body failed before serving the request");
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
+    catch {
+        return undefined;
     }
-    fact =
-        service === undefined
-            ? await voidRequest(input.paths, request.id, "body completed without a durable Contract fact reference")
-            : await serveUpstreamRequest(input.paths, request.id, service);
-    await projectReceipt(input.directory, input.transportId, fact, outcome);
 }
 export async function serveRequest(input) {
-    return input.claim.action === "akuma.call"
-        ? await serveCall({ ...input, claim: input.claim })
-        : await serveUpstream({ ...input, claim: input.claim });
+    const command = input.commands[input.claim.action];
+    if (command === undefined) {
+        await atomicJson(receiptPath(input.directory, input.transportId), {
+            id: input.claim.id,
+            action: input.claim.action,
+            state: "refused",
+            diagnostic: `request action ${input.claim.action} is not registered`,
+        });
+        return true;
+    }
+    return await serveCommand(input, command);
 }
 async function serveTransportClaim(input) {
     try {
-        await serveRequest(input);
+        return await serveRequest(input);
     }
     catch (error) {
         if (!isRequestInputConflict(error))
@@ -257,10 +129,11 @@ async function serveTransportClaim(input) {
             state: "refused",
             diagnostic: error.message,
         });
+        return true;
     }
 }
 export class BodyRequestPump extends LifecycleBodyRequestPump {
     static async open(input) {
-        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveTransportClaim(claim)));
+        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveTransportClaim({ ...claim, commands: input.commands })));
     }
 }