@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/providers/pi/index.js

@@ -21,26 +21,14 @@ function admitPiOptions(options) {
         options: Object.freeze({ ...options }),
     };
 }
-async function piCreateOptions(sdk, input) {
+function piCreateOptions(sdk, input, services) {
     let model;
-    let modelRuntime;
     if (input.options.model !== undefined) {
         const slash = input.options.model.indexOf("/");
-        modelRuntime = await sdk.ModelRuntime.create();
-        model = modelRuntime.getModel(input.options.model.slice(0, slash), input.options.model.slice(slash + 1));
+        model = services.modelRuntime.getModel(input.options.model.slice(0, slash), input.options.model.slice(slash + 1));
         if (model === undefined)
             throw new Error(`Pi model '${input.options.model}' is unavailable`);
     }
-    const resourceLoader = input.options.systemPrompt === undefined
-        ? undefined
-        : new sdk.DefaultResourceLoader({
-            cwd: input.cwd,
-            agentDir: sdk.getAgentDir(),
-            ...(input.options.systemPromptMode === "append"
-                ? { appendSystemPromptOverride: (base) => [...base, input.options.systemPrompt] }
-                : { systemPromptOverride: () => input.options.systemPrompt }),
-        });
-    await resourceLoader?.reload();
     const sessionManager = input.session.kind === "fresh"
         ? sdk.SessionManager.create(input.cwd)
         : "sessionFile" in input.session.coordinate
@@ -59,22 +47,39 @@ async function piCreateOptions(sdk, input) {
             }),
         ];
     return {
-        cwd: input.cwd,
+        services,
         sessionManager,
-        ...(model === undefined || modelRuntime === undefined ? {} : { model, modelRuntime }),
-        ...(resourceLoader === undefined ? {} : { resourceLoader }),
+        ...(model === undefined ? {} : { model }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
         ...(customTools === undefined ? {} : { customTools }),
     };
 }
 async function createPiSession(sdk, execution, input) {
-    const setup = piCreateOptions(sdk, input).then(async (options) => {
-        if (execution.config !== undefined) {
-            throw new TypeError("Pi provider config cannot be consumed by native CreateAgentSessionOptions");
-        }
-        return await sdk.createAgentSession(options);
+    if (execution.config !== undefined) {
+        throw new TypeError("Pi provider config cannot be consumed by native CreateAgentSessionOptions");
+    }
+    const services = await sdk.createAgentSessionServices({
+        cwd: input.cwd,
+        agentDir: sdk.getAgentDir(),
+        modelRuntimeSignal: input.signal,
+        ...(input.options.systemPrompt === undefined
+            ? {}
+            : {
+                resourceLoaderOptions: input.options.systemPromptMode === "append"
+                    ? { appendSystemPromptOverride: (base) => [...base, input.options.systemPrompt] }
+                    : { systemPromptOverride: () => input.options.systemPrompt },
+            }),
     });
-    return await setup;
+    try {
+        input.signal?.throwIfAborted();
+        return await sdk.createAgentSessionFromServices(piCreateOptions(sdk, input, services));
+    }
+    catch (error) {
+        // Before a session owns the extension runtime, failed selection/setup must
+        // retire registrations and event-bus subscriptions loaded by the services.
+        services.resourceLoader.getExtensions().runtime.invalidate();
+        throw error;
+    }
 }
 async function runPiPrompt(native, input, events, state, settle) {
     try {
@@ -126,20 +131,51 @@ async function drivePi(sdk, execution, input, signal, custody) {
         aborting: false,
         settled: false,
     };
+    const pendingTells = new Map();
+    const endPendingTells = () => {
+        for (const waiter of pendingTells.values())
+            waiter.resolve({ kind: "turn-ended" });
+        pendingTells.clear();
+    };
     let settleCompletion;
     const completion = new Promise((resolve) => {
         settleCompletion = resolve;
     });
-    const unsubscribe = native.subscribe((event) => {
-        if (event.type === "agent_end" && !event.willRetry)
-            state.terminalFailure = piTerminalFailure(event.messages);
-        for (const translated of translatePiEvent(event, eventState))
-            events.emit(translated);
-    });
+    const agent = native.agent;
+    let unsubscribeAgent;
+    let unsubscribe;
+    try {
+        unsubscribeAgent = agent.subscribe((event) => {
+            if (event.type === "message_end") {
+                const waiter = pendingTells.get(event.message);
+                if (waiter !== undefined) {
+                    pendingTells.delete(event.message);
+                    waiter.resolve({ kind: "accepted", fence: `${native.sessionId}:${waiter.id}` });
+                }
+            }
+        });
+        unsubscribe = native.subscribe((event) => {
+            if (event.type === "agent_end" && !event.willRetry) {
+                state.terminalFailure = piTerminalFailure(event.messages);
+            }
+            for (const translated of translatePiEvent(event, eventState))
+                events.emit(translated);
+        });
+    }
+    catch (error) {
+        try {
+            unsubscribeAgent?.();
+        }
+        finally {
+            native.dispose();
+        }
+        throw error;
+    }
     const settle = (result) => {
         if (state.settled)
             return closed;
         state.settled = true;
+        endPendingTells();
         let failure;
         try {
             unsubscribe();
@@ -147,19 +183,19 @@ async function drivePi(sdk, execution, input, signal, custody) {
         catch (error) {
             failure = error;
         }
-        finally {
-            try {
-                events.end();
-            }
-            finally {
-                settleCompletion(result);
-                try {
-                    native.dispose();
-                }
-                catch (error) {
-                    failure ??= error;
-                }
-            }
+        try {
+            unsubscribeAgent?.();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+        events.end();
+        settleCompletion(result);
+        try {
+            native.dispose();
+        }
+        catch (error) {
+            failure ??= error;
         }
         if (failure === undefined)
             settleRetired();
@@ -189,6 +225,25 @@ async function drivePi(sdk, execution, input, signal, custody) {
         admission: { fence: native.sessionId },
         events,
         completion,
+        tell: (tell) => {
+            if (state.settled)
+                return Promise.resolve({ kind: "turn-ended" });
+            const message = {
+                role: "user",
+                content: [{ type: "text", text: tell.text }],
+                timestamp: new Date().getTime(),
+            };
+            return new Promise((resolve, reject) => {
+                pendingTells.set(message, { id: tell.id, resolve });
+                try {
+                    agent.steer(message);
+                }
+                catch (error) {
+                    pendingTells.delete(message);
+                    reject(error);
+                }
+            });
+        },
         abort: () => {
             state.abortRequest ??= (async () => {
                 if (state.settled)
@@ -223,11 +278,10 @@ async function forkPi(sdk, input) {
 async function loadPiSdk() {
     const sdk = await import("@earendil-works/pi-coding-agent");
     return {
-        createAgentSession: sdk.createAgentSession,
+        createAgentSessionFromServices: sdk.createAgentSessionFromServices,
+        createAgentSessionServices: sdk.createAgentSessionServices,
         createBashToolDefinition: sdk.createBashToolDefinition,
-        DefaultResourceLoader: sdk.DefaultResourceLoader,
         getAgentDir: sdk.getAgentDir,
-        ModelRuntime: sdk.ModelRuntime,
         SessionManager: sdk.SessionManager,
     };
 }

package/build/src/akuma/publication.d.ts

@@ -1,5 +1,9 @@
-import { type AllocatedAkuma } from "./identity.js";
+import { type Soul } from "./heart/index.js";
+import { type AllocatedAkuma, type AkumaPaths, type AkuId } from "./identity.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
+import type { RequestRecipe } from "./heart/facts.js";
+import type { CallInitialTell, CallInitialTellAdmission, TellResult } from "./call-initial-tell.js";
+import { type WorldRoot } from "../world.js";
 export declare const BIRTH_TIMEOUT_MS = 30000;
 export type BirthInput = Readonly<{
     worldPath: string;
@@ -12,6 +16,83 @@ export type LaunchInput = Readonly<{
     launch(allocated: AllocatedAkuma): Promise<OwnedProcess | void>;
     signal?: AbortSignal;
 }>;
-export declare function birthAkuma(input: BirthInput): Promise<AllocatedAkuma>;
-export declare function launchAkuma(input: LaunchInput): Promise<AllocatedAkuma>;
 export declare function publishAkuma(input: BirthInput & Omit<LaunchInput, "allocated">): Promise<AllocatedAkuma>;
+/**
+ * The one prepared-call recipe shape, owned by the Heart Soul projection. Both
+ * custody kinds carry the same raw recipe: the decoded provider execution plus
+ * the options the one prepared-call executor admits exactly once.
+ */
+export type PreparedCallRecipe = RequestRecipe;
+/**
+ * The one owner-typed admission failure the prepared executor raises before any
+ * allocation. It carries only the failing stage and the provider owner's native
+ * diagnostic; the initiating edge maps it back to its own refusal meaning.
+ */
+export declare class PreparedCallAdmissionError extends Error {
+    readonly stage: "resolve" | "options";
+    readonly diagnostic: string;
+    readonly kind = "prepared-call-admission";
+    constructor(stage: "resolve" | "options", diagnostic: string);
+}
+export type PreparedCallSpawn = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+}>;
+export type PreparedCallInitialTellAdmission = Readonly<{
+    id: AkuId;
+    initialTell: CallInitialTell;
+    signal?: AbortSignal;
+}>;
+type PreparedCallPorts = Readonly<{
+    /** Spawn one already-allocated child; publication already owns the allocated directory. */
+    spawn(launch: PreparedCallSpawn): Promise<OwnedProcess | void>;
+    /** Admit the optional initial Tell against the just-confirmed child. */
+    admitInitialTell(input: PreparedCallInitialTellAdmission): Promise<CallInitialTellAdmission>;
+}>;
+/**
+ * The one discriminated custody the prepared executor serves. Local custody
+ * carries the initiating process's own proved World and local spawn/initial-Tell
+ * ports. Request custody carries the authenticated direct parent, the serving
+ * request identity, the reservation edge, and the parent scope its allowed
+ * actions are clipped against. Both kinds carry the same raw recipe.
+ */
+type PreparedCallCustody = (PreparedCallPorts & Readonly<{
+    kind: "local";
+    world: WorldRoot;
+    recipe: PreparedCallRecipe;
+}>) | (PreparedCallPorts & Readonly<{
+    kind: "request";
+    world: WorldRoot;
+    coordinate: string;
+    recipe: PreparedCallRecipe;
+    parent: Soul;
+    requestId: string;
+    admissionOpen(): boolean;
+    reserve(child: AkuId): Promise<void>;
+    refuse(diagnostic: string): Promise<void>;
+}>);
+type PreparedCallResult = Readonly<{
+    child: AllocatedAkuma;
+    /** The exact initial TellResult, present only when its admission completed. */
+    tell?: TellResult;
+    /** The native launch or initial-Tell failure that stopped after a confirmed birth. */
+    failure?: unknown;
+}>;
+type PreparedCallInput = Readonly<{
+    archetype: string;
+    cwd: string;
+    initialTell?: CallInitialTell;
+    signal?: AbortSignal;
+    custody: PreparedCallCustody;
+}>;
+export declare function callDiagnostic(error: unknown): string;
+/**
+ * The one lower birth owner for a prepared call. It alone orders World
+ * proof/consumption, request-custody provider resolution and options admission,
+ * allowed clipping, child allocation, the launch admission gate and reservation,
+ * spawn/publication, and optional initial-Tell admission. It never loads
+ * Settings or an Archetype and never imports Library, and it never replaces a
+ * durably born child with a thrown error.
+ */
+export declare function executePreparedCall(input: PreparedCallInput): Promise<PreparedCallResult>;
+export {};

package/build/src/akuma/publication.js

@@ -2,6 +2,9 @@ import { HeldAkumaLeash, initializeHeart, readHeart, readSeal, readSoul } from "
 import { acquireLeash } from "./control.js";
 import { allocateAkumaDirectory } from "./identity.js";
 import { abortableDelay } from "./abort.js";
+import { clipAllowedActions } from "./allowed.js";
+import { resolveProviderExecution } from "./providers/index.js";
+import { World } from "../world.js";
 const POLL_MS = 100;
 const CUSTODY_HANDOFF_MS = 1_000;
 export const BIRTH_TIMEOUT_MS = 30_000;
@@ -220,7 +223,7 @@ async function sealLocalFailure(allocated, error) {
         /* the original local publication failure remains authoritative */
     }
 }
-export async function birthAkuma(input) {
+async function birthAkuma(input) {
     input.signal?.throwIfAborted();
     const allocated = await allocateAkumaDirectory({ worldRoot: input.worldPath, archetype: input.archetype });
     try {
@@ -233,7 +236,7 @@ export async function birthAkuma(input) {
         throw error;
     }
 }
-export async function launchAkuma(input) {
+async function launchAkuma(input) {
     const { allocated } = input;
     let owned = undefined;
     try {
@@ -272,3 +275,143 @@ export async function publishAkuma(input) {
     const allocated = await birthAkuma(input);
     return await launchAkuma({ ...input, allocated });
 }
+/**
+ * The one owner-typed admission failure the prepared executor raises before any
+ * allocation. It carries only the failing stage and the provider owner's native
+ * diagnostic; the initiating edge maps it back to its own refusal meaning.
+ */
+export class PreparedCallAdmissionError extends Error {
+    stage;
+    diagnostic;
+    kind = "prepared-call-admission";
+    constructor(stage, diagnostic) {
+        super(diagnostic);
+        this.stage = stage;
+        this.diagnostic = diagnostic;
+        this.name = "PreparedCallAdmissionError";
+    }
+}
+export function callDiagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * The one provider-owner admission shared by both custody kinds: resolve the
+ * decoded execution to its adapter, admit the raw options once, and clip the
+ * requested actions only when a parent ceiling applies.
+ */
+async function admittedRecipe(recipe, bounds = {}) {
+    let selected;
+    try {
+        selected = await resolveProviderExecution(recipe.provider);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new PreparedCallAdmissionError("resolve", error.message);
+        throw error;
+    }
+    const admission = selected.adapter.admitOptions(recipe.options);
+    if (admission.kind === "refused") {
+        if (bounds.refuse !== undefined)
+            await bounds.refuse(admission.diagnostic);
+        throw new PreparedCallAdmissionError("options", admission.diagnostic);
+    }
+    return Object.freeze({
+        ...(recipe.description === undefined ? {} : { description: recipe.description }),
+        provider: selected.execution,
+        options: admission.options,
+        allowed: bounds.ceiling === undefined ? recipe.allowed : clipAllowedActions(recipe.allowed, bounds.ceiling),
+    });
+}
+/** Judge durable birth from the allocated child's own evidence, never from the caught error. */
+async function durablyBorn(allocated) {
+    const soul = await readSoul(allocated.paths);
+    return soul !== null && soul.id === allocated.id;
+}
+/**
+ * The one lower birth owner for a prepared call. It alone orders World
+ * proof/consumption, request-custody provider resolution and options admission,
+ * allowed clipping, child allocation, the launch admission gate and reservation,
+ * spawn/publication, and optional initial-Tell admission. It never loads
+ * Settings or an Archetype and never imports Library, and it never replaces a
+ * durably born child with a thrown error.
+ */
+export async function executePreparedCall(input) {
+    const { custody } = input;
+    let world;
+    if (custody.kind === "local") {
+        world = custody.world;
+    }
+    else {
+        const requestWorld = await World.prove(custody.coordinate);
+        if (requestWorld !== custody.world) {
+            const diagnostic = `request world ${requestWorld} does not match ${custody.world}`;
+            await custody.refuse(diagnostic);
+            throw new Error(diagnostic);
+        }
+        world = custody.world;
+    }
+    const recipe = custody.kind === "request"
+        ? await admittedRecipe(custody.recipe, { ceiling: custody.parent.allowed, refuse: custody.refuse })
+        : await admittedRecipe(custody.recipe);
+    const origin = custody.kind === "request"
+        ? { kind: "request", parent: custody.parent.id, requestId: custody.requestId }
+        : { kind: "direct" };
+    const allocated = await birthAkuma({
+        worldPath: world,
+        archetype: input.archetype,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    let child = allocated;
+    try {
+        child = await launchAkuma({
+            allocated,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            launch: async (ready) => {
+                if (custody.kind === "request") {
+                    if (!custody.admissionOpen())
+                        throw new Error("body closed request admission");
+                    await custody.reserve(ready.id);
+                }
+                return await custody.spawn({
+                    paths: ready.paths,
+                    seed: {
+                        id: ready.id,
+                        archetype: ready.archetype,
+                        ...(recipe.description === undefined ? {} : { description: recipe.description }),
+                        provider: recipe.provider,
+                        options: recipe.options,
+                        allowed: recipe.allowed,
+                        cwd: input.cwd,
+                        origin,
+                    },
+                });
+            },
+        });
+    }
+    catch (error) {
+        if (!(await durablyBorn(allocated)))
+            throw error;
+        return { child: allocated, failure: error };
+    }
+    if (input.initialTell === undefined)
+        return { child };
+    let told;
+    try {
+        const admitted = await custody.admitInitialTell({
+            id: child.id,
+            initialTell: input.initialTell,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+        if (admitted.kind === "birth-failed")
+            throw new Error(admitted.diagnostic);
+        if (admitted.kind === "not-born")
+            throw new Error(`Akuma ${child.id} was not born for its initial Tell`);
+        told = await admitted.wake;
+        return { child, tell: told };
+    }
+    catch (error) {
+        if (told !== undefined)
+            return { child, tell: told };
+        return { child, failure: error };
+    }
+}

package/build/src/akuma/read-pool.d.ts

@@ -0,0 +1,2 @@
+export declare const PAGE_POOL_SIZE = 16;
+export declare function boundedMap<Value, Result>(values: readonly Value[], mapper: (value: Value) => Promise<Result>): Promise<readonly Result[]>;

package/build/src/akuma/read-pool.js

@@ -0,0 +1,15 @@
+export const PAGE_POOL_SIZE = 16;
+export async function boundedMap(values, mapper) {
+    const results = [];
+    let index = 0;
+    const worker = async () => {
+        for (;;) {
+            const selected = index++;
+            if (selected >= values.length)
+                return;
+            results[selected] = await mapper(values[selected]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(PAGE_POOL_SIZE, values.length) }, worker));
+    return results;
+}

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

@@ -53,6 +53,16 @@ async function readRequestReceipt(input, path, id) {
         if (receipt.state === "refused") {
             throw new AkumaBodyRequestError(receipt.action, "refused", receipt.diagnostic, receipt.id);
         }
+        if (receipt.state === "voided" && receipt.outcome !== undefined) {
+            let result;
+            try {
+                result = input.command.decodeResult(receipt.outcome);
+            }
+            catch (error) {
+                throw new Error(`transport integrity: invalid voided live result: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return withRequestMetadata({ kind: "returned", result }, id, input.command.action);
+        }
         if (receipt.state === "voided") {
             throwVoidedRequestFailure(receipt.action, receipt.evidence, receipt.failure, input.command.decodeFailure, receipt.id);
         }

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

@@ -30,6 +30,7 @@ async function projectCommandReceipt(input, fact, command, outcome, failure) {
                 state: "voided",
                 evidence: fact.evidence,
                 ...(failure === undefined ? {} : { failure }),
+                ...(outcome === undefined ? {} : { outcome: outcome.result }),
             }
             : fact.state === "unproven"
                 ? {
@@ -152,6 +153,12 @@ async function serveServiceCommand(input, command) {
     return await serveResolvedCommand(input, command, request, async (fact, facts) => {
         await beginRequest(input.paths, fact.id);
         const served = await request.execute(facts);
+        if (served.kind === "voided") {
+            return {
+                fact: await voidRequest(input.paths, fact.id, "returned owner outcome was voided"),
+                outcome: { kind: "returned", result: served.outcome },
+            };
+        }
         return {
             fact: await serveUpstreamRequest(input.paths, fact.id, served.serviceJson),
             outcome: { kind: "returned", result: served.result },

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

@@ -4,26 +4,6 @@ declare const requestEnvelopeSchema: z.ZodObject<{
     action: z.ZodString;
     payload: z.ZodUnknown;
 }, z.core.$strict>;
-declare const upstreamRequestFailureSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"akuma-not-born">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"failed">;
-    diagnostic: z.ZodString;
-}, z.core.$strict>]>;
-declare const returnedEnvelopeSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"returned">;
-    result: z.ZodUnknown;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"failed">;
-    failure: z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"akuma-not-born">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"failed">;
-        diagnostic: z.ZodString;
-    }, z.core.$strict>]>;
-}, z.core.$strict>]>;
 declare const receiptEnvelopeSchema: z.ZodUnion<readonly [z.ZodObject<{
     id: z.ZodString;
     action: z.ZodString;
@@ -57,6 +37,7 @@ declare const receiptEnvelopeSchema: z.ZodUnion<readonly [z.ZodObject<{
     state: z.ZodLiteral<"voided">;
     evidence: z.ZodString;
     failure: z.ZodOptional<z.ZodUnknown>;
+    outcome: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     action: z.ZodString;
@@ -100,16 +81,21 @@ export type ChildRequestCommand<Input, Output, Reference> = Readonly<{
         child: string;
     }>>;
 }>;
+export type ServiceCompletion<Output, Service> = Readonly<{
+    kind: "served";
+    result: Output;
+    service: Service;
+}> | Readonly<{
+    kind: "voided";
+    outcome: Output;
+}>;
 export type ServiceRequestCommand<Input, Output, Service, Reference> = Readonly<{
     completion: "service";
     protocol: RequestProtocol<Input, Output, Reference>;
     encodeService(service: Service): unknown;
     decodeService(service: unknown): Service;
     projectService(service: Service): Reference;
-    execute(input: Input, facts: ExecutionFacts): Promise<Readonly<{
-        result: Output;
-        service: Service;
-    }>>;
+    execute(input: Input, facts: ExecutionFacts): Promise<ServiceCompletion<Output, Service>>;
 }>;
 type ErasedRequest = Readonly<{
     payloadJson: string;
@@ -125,8 +111,12 @@ type ErasedChildRequest = ErasedRequest & Readonly<{
 }>;
 type ErasedServiceRequest = ErasedRequest & Readonly<{
     execute(facts: ExecutionFacts): Promise<Readonly<{
+        kind: "served";
         result: unknown;
         serviceJson: string;
+    }> | Readonly<{
+        kind: "voided";
+        outcome: unknown;
     }>>;
 }>;
 export type ErasedRequestCommand = Readonly<{
@@ -144,8 +134,6 @@ export type ErasedRequestCommand = Readonly<{
 export declare function eraseRequestCommand<Input, Output, Reference>(command: ChildRequestCommand<Input, Output, Reference>): ErasedRequestCommand;
 export declare function eraseRequestCommand<Input, Output, Service, Reference>(command: ServiceRequestCommand<Input, Output, Service, Reference>): ErasedRequestCommand;
 export declare function composeRequestCommands(...maps: readonly Readonly<Record<string, ErasedRequestCommand>>[]): Readonly<Record<string, ErasedRequestCommand>>;
-export type UpstreamRequestFailure = z.infer<typeof upstreamRequestFailureSchema>;
-export type ReturnedEnvelope = z.infer<typeof returnedEnvelopeSchema>;
 export type ReceiptEnvelope = z.infer<typeof receiptEnvelopeSchema>;
 export declare function decodeEnvelope(bytes: string, fileId: string): RequestEnvelope | null;
 export declare function decodeReceiptEnvelope(bytes: string, id: string, action: string): ReceiptEnvelope | null;

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

@@ -27,6 +27,7 @@ const receiptEnvelopeSchema = z.union([
         state: z.literal("voided"),
         evidence: z.string(),
         failure: z.unknown().optional(),
+        outcome: z.unknown().optional(),
     })
         .strict(),
     z
@@ -78,7 +79,10 @@ export function eraseRequestCommand(command) {
                         isPermitted: (allowed) => protocol.isPermitted(allowed),
                         execute: async (facts) => {
                             const served = await command.execute(input, facts);
+                            if (served.kind === "voided")
+                                return { kind: "voided", outcome: protocol.encodeResult(served.outcome) };
                             return {
+                                kind: "served",
                                 result: protocol.encodeResult(served.result),
                                 serviceJson: JSON.stringify(command.encodeService(served.service)),
                             };

package/build/src/akuma/requests.d.ts

@@ -15,6 +15,4 @@ export declare function bodyRequestExecutionContext(directory: unknown): Executi
 export declare function bodyRequestExecution(input: Readonly<{
     directory: string;
 }>): LibraryExecution;
-/** Normalizes the public carrier before a composition captures its immutable channel. */
-export declare function libraryExecution(value: unknown): LibraryExecution;
 export declare function executionChannel(context?: ExecutionContext): ExecutionChannel;

package/build/src/akuma/requests.js

@@ -35,23 +35,6 @@ export function bodyRequestExecution(input) {
         throw new TypeError(error instanceof Error ? error.message : String(error));
     }
 }
-/** Normalizes the public carrier before a composition captures its immutable channel. */
-export function libraryExecution(value) {
-    const context = valueRecord(value, "execution");
-    closed(context, ["channel"], "execution");
-    const channel = valueRecord(context.channel, "execution channel");
-    if (channel.kind === "local") {
-        closed(channel, ["kind"], "execution channel");
-        return localExecutionContext();
-    }
-    if (channel.kind === "body-request") {
-        closed(channel, ["directory", "kind"], "execution channel");
-        if (typeof channel.directory !== "string")
-            throw new TypeError("execution channel directory must be a string");
-        return bodyRequestExecution({ directory: channel.directory });
-    }
-    throw new TypeError("execution channel must be local or body-request");
-}
 export function executionChannel(context) {
     return context?.channel ?? LOCAL_CHANNEL;
 }