@astrosheep/keiyaku 4.5.11 → 4.5.13

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

@@ -1,7 +1,24 @@
-import { admitRequest, isRequestInputConflict, readRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
+import { admitRequest, beginRequest, isRequestInputConflict, readHeart, readRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, unproveRequest, } from "./heart/index.js";
 import { atomicJson, receiptPath, } from "./request-wire.js";
-import { BodyRequestPump as LifecycleBodyRequestPump, } from "./request-lifecycle.js";
+import { BodyRequestPump as LifecycleBodyRequestPump, settleReserved, } from "./request-lifecycle.js";
 export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
+function replayReference(fact, command) {
+    if (fact.state !== "served") {
+        throw new Error(`request ${fact.id} completion corruption: cannot replay ${fact.state} request`);
+    }
+    switch (command.completion) {
+        case "child":
+            if (!("child" in fact)) {
+                throw new Error(`request ${fact.id} completion corruption: child command has a service settlement`);
+            }
+            return command.projectChild(fact.child);
+        case "service":
+            if (!("serviceJson" in fact)) {
+                throw new Error(`request ${fact.id} completion corruption: service command has a child settlement`);
+            }
+            return command.projectServiceJson(fact.serviceJson);
+    }
+}
 async function projectCommandReceipt(input, fact, command, outcome, failure) {
     const receipt = fact.state === "refused"
         ? { id: fact.id, action: fact.action, state: "refused", diagnostic: fact.diagnostic }
@@ -13,25 +30,22 @@ async function projectCommandReceipt(input, fact, command, outcome, failure) {
                 evidence: fact.evidence,
                 ...(failure === undefined ? {} : { failure }),
             }
-            : outcome === undefined
-                ? "serviceJson" in fact
+            : fact.state === "unproven"
+                ? {
+                    id: fact.id,
+                    action: fact.action,
+                    state: "unproven",
+                    evidence: fact.evidence,
+                    ...(failure === undefined ? {} : { failure }),
+                }
+                : outcome === undefined
                     ? {
                         id: fact.id,
                         action: fact.action,
                         state: "served",
-                        reference: command.projectServiceJson(fact.serviceJson),
+                        reference: replayReference(fact, command),
                     }
-                    : "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;
+                    : { id: fact.id, action: fact.action, state: "served", outcome };
     try {
         await atomicJson(receiptPath(input.directory, input.transportId), receipt);
     }
@@ -40,57 +54,95 @@ async function projectCommandReceipt(input, fact, command, outcome, failure) {
             throw error;
     }
 }
-async function serveCommand(input, command) {
-    const request = command.resolve(input.claim.payload);
-    if (request === null)
-        throw new Error(`registered request action ${input.claim.action} rejected its payload`);
+async function serveResolvedCommand(input, command, request, execute) {
     let fact = await admitRequest(input.paths, {
         id: input.claim.id,
         action: input.claim.action,
         payloadJson: request.payloadJson,
         admittedAt: input.now(),
-        permitted: request.isPermitted(input.parent.allowed),
+        permitted: request.isPermitted(input.allowed),
     });
     if (fact.state !== "admitted") {
-        await projectCommandReceipt(input, fact, request);
+        await projectCommandReceipt(input, fact, command);
         return true;
     }
     if (!input.admissionOpen()) {
         fact = await voidRequest(input.paths, fact.id, "body closed request admission");
-        await projectCommandReceipt(input, fact, request);
+        await projectCommandReceipt(input, fact, command);
         return true;
     }
     try {
-        const served = await request.execute({
+        const facts = {
             id: fact.id,
             admittedAt: fact.admittedAt,
             requester: fact.requester,
             signal: input.signal,
-            upstream: input.upstream,
-            paths: input.paths,
-            parent: input.parent,
-            spawn: input.spawn,
             admissionOpen: input.admissionOpen,
-        });
-        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 });
+        };
+        const served = await execute(fact, facts);
+        fact = served.fact;
+        await projectCommandReceipt(input, fact, command, served.outcome);
     }
     catch (error) {
         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, fact.id, diagnostic(error))
-                : current;
-        await projectCommandReceipt(input, fact, request, undefined, failure);
+        if (current.state === "reserved") {
+            const parent = (await readHeart(input.paths)).soul;
+            if (parent === null)
+                throw new Error("reserved request settlement requires a born parent Soul");
+            if (!(await settleReserved(input.paths, parent, current, input.now, input.signal)))
+                return true;
+            fact = (await readRequest(input.paths, fact.id)) ?? current;
+        }
+        else {
+            fact =
+                current.state === "admitted"
+                    ? await voidRequest(input.paths, fact.id, diagnostic(error))
+                    : current.state === "begun"
+                        ? provesNoProductEffect(failure)
+                            ? await voidRequest(input.paths, fact.id, diagnostic(error))
+                            : await unproveRequest(input.paths, fact.id, diagnostic(error))
+                        : current;
+        }
+        await projectCommandReceipt(input, fact, command, undefined, failure);
     }
     return true;
 }
+async function serveChildCommand(input, command) {
+    const request = command.resolve(input.claim.payload);
+    if (request === null)
+        throw new Error(`registered request action ${input.claim.action} rejected its payload`);
+    return await serveResolvedCommand(input, command, request, async (fact, facts) => {
+        const served = await request.execute(facts);
+        return {
+            fact: await serveChildRequest(input.paths, fact.id, served.child),
+            outcome: { kind: "returned", result: served.result },
+        };
+    });
+}
+async function serveServiceCommand(input, command) {
+    const request = command.resolve(input.claim.payload);
+    if (request === null)
+        throw new Error(`registered request action ${input.claim.action} rejected its payload`);
+    return await serveResolvedCommand(input, command, request, async (fact, facts) => {
+        await beginRequest(input.paths, fact.id);
+        const served = await request.execute(facts);
+        return {
+            fact: await serveUpstreamRequest(input.paths, fact.id, served.serviceJson),
+            outcome: { kind: "returned", result: served.result },
+        };
+    });
+}
+async function serveCommand(input, command) {
+    switch (command.completion) {
+        case "child":
+            return await serveChildCommand(input, command);
+        case "service":
+            return await serveServiceCommand(input, command);
+    }
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -103,6 +155,9 @@ function encodedFailure(request, error) {
         return undefined;
     }
 }
+function provesNoProductEffect(failure) {
+    return failure !== null && typeof failure === "object" && failure.kind === "refused";
+}
 export async function serveRequest(input) {
     const command = input.commands[input.claim.action];
     if (command === undefined) {

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

@@ -57,13 +57,19 @@ declare const receiptEnvelopeSchema: z.ZodUnion<readonly [z.ZodObject<{
     state: z.ZodLiteral<"voided">;
     evidence: z.ZodString;
     failure: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    state: z.ZodLiteral<"unproven">;
+    evidence: z.ZodString;
+    failure: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strict>]>;
 export type RequestEnvelope = z.infer<typeof requestEnvelopeSchema>;
 /**
  * A Body Request operation is owned by the verb that defines its public
  * values.  Transport only carries the opaque values produced here.
  */
-export type RequestCommand<Input, Output, Service, Reference = Service, Context = unknown> = Readonly<{
+export type RequestProtocol<Input, Output, Reference> = Readonly<{
     action: string;
     encodeRequest(input: Input): unknown;
     decodeRequest(payload: unknown): Input | null;
@@ -71,43 +77,68 @@ export type RequestCommand<Input, Output, Service, Reference = Service, Context
     decodeResult(result: unknown): Output;
     encodeFailure?(error: unknown): unknown | null;
     decodeFailure?(failure: unknown): Error | null;
-    encodeService(service: Service): unknown;
-    decodeService(service: unknown): Service;
-    projectService(service: Service): Reference;
-    projectChild?(child: string): Reference;
     decodeReference(reference: unknown): Reference;
-    /** The operation owner proves the Body-owned execution capability before use. */
-    decodeExecutionContext(value: unknown): Context;
     isPermitted(allowed: readonly string[]): boolean;
-    execute(input: Input, context: Context): Promise<Readonly<{
+}>;
+export type ExecutionFacts = Readonly<{
+    id: string;
+    admittedAt: string;
+    requester: string;
+    signal: AbortSignal;
+    admissionOpen(): boolean;
+}>;
+export type ChildRequestCommand<Input, Output, Reference> = Readonly<{
+    completion: "child";
+    protocol: RequestProtocol<Input, Output, Reference>;
+    projectChild(child: string): Reference;
+    execute(input: Input, facts: ExecutionFacts): Promise<Readonly<{
         result: Output;
-    }> & (Readonly<{
-        service: Service;
-    }> | Readonly<{
         child: string;
-    }>)>;
+    }>>;
 }>;
-export type ErasedRequestCommand = Readonly<{
-    action: string;
-    resolve(payload: unknown): ErasedRequest | null;
+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;
+    }>>;
 }>;
-export type ErasedRequest = Readonly<{
+type ErasedRequest = Readonly<{
     payloadJson: string;
     isPermitted(allowed: readonly string[]): boolean;
-    execute(context: unknown): Promise<ErasedRequestExecution>;
     encodeFailure(error: unknown): unknown | null;
-    projectServiceJson(serviceJson: string): unknown;
-    projectChild(child: string): unknown;
 }>;
-export type ErasedRequestExecution = Readonly<{
-    result: unknown;
-    serviceJson: string;
+type ErasedChildRequest = ErasedRequest & Readonly<{
+    execute(facts: ExecutionFacts): Promise<Readonly<{
+        result: unknown;
+        child: string;
+    }>>;
+}>;
+type ErasedServiceRequest = ErasedRequest & Readonly<{
+    execute(facts: ExecutionFacts): Promise<Readonly<{
+        result: unknown;
+        serviceJson: string;
+    }>>;
+}>;
+export type ErasedRequestCommand = Readonly<{
+    action: string;
+    completion: "child";
+    projectChild(child: string): unknown;
+    resolve(payload: unknown): ErasedChildRequest | null;
 }> | Readonly<{
-    result: unknown;
-    child: string;
+    action: string;
+    completion: "service";
+    projectServiceJson(serviceJson: string): unknown;
+    resolve(payload: unknown): ErasedServiceRequest | null;
 }>;
 /** Erases only static TypeScript parameters; each operation codec remains captured by its owner descriptor. */
-export declare function eraseRequestCommand<Input, Output, Service, Reference, Context>(command: RequestCommand<Input, Output, Service, Reference, Context>): ErasedRequestCommand;
+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>;
@@ -115,5 +146,5 @@ export declare function decodeEnvelope(bytes: string, fileId: string): RequestEn
 export declare function decodeReceiptEnvelope(bytes: string, id: string, action: string): ReceiptEnvelope | null;
 export declare function requestPath(directory: string, id: string): string;
 export declare function receiptPath(directory: string, id: string): string;
-export declare function atomicJson(path: string, value: unknown): Promise<void>;
+export declare function atomicJson(path: string, value: unknown, signal?: AbortSignal, beforeRename?: () => void | Promise<void>): Promise<void>;
 export {};

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

@@ -29,37 +29,74 @@ const receiptEnvelopeSchema = z.union([
         failure: z.unknown().optional(),
     })
         .strict(),
+    z
+        .object({
+        id: requestIdSchema,
+        action: actionSchema,
+        state: z.literal("unproven"),
+        evidence: z.string(),
+        failure: z.unknown().optional(),
+    })
+        .strict(),
 ]);
-/** Erases only static TypeScript parameters; each operation codec remains captured by its owner descriptor. */
 export function eraseRequestCommand(command) {
-    return {
-        action: command.action,
-        resolve: (payload) => {
-            const input = command.decodeRequest(payload);
-            if (input === null)
-                return null;
+    const { protocol } = command;
+    switch (command.completion) {
+        case "child":
             return {
-                payloadJson: JSON.stringify(command.encodeRequest(input)),
-                isPermitted: (allowed) => command.isPermitted(allowed),
-                execute: async (context) => {
-                    const served = await command.execute(input, command.decodeExecutionContext(context));
-                    return "child" in served
-                        ? { result: command.encodeResult(served.result), child: served.child }
-                        : {
-                            result: command.encodeResult(served.result),
-                            serviceJson: JSON.stringify(command.encodeService(served.service)),
-                        };
+                action: protocol.action,
+                completion: "child",
+                projectChild: command.projectChild,
+                resolve: (payload) => {
+                    const input = protocol.decodeRequest(payload);
+                    if (input === null)
+                        return null;
+                    return {
+                        payloadJson: JSON.stringify(protocol.encodeRequest(input)),
+                        isPermitted: (allowed) => protocol.isPermitted(allowed),
+                        execute: async (facts) => {
+                            const served = await command.execute(input, facts);
+                            return { result: protocol.encodeResult(served.result), child: served.child };
+                        },
+                        encodeFailure: (error) => protocol.encodeFailure?.(error) ?? null,
+                    };
                 },
-                encodeFailure: (error) => command.encodeFailure?.(error) ?? null,
+            };
+        case "service":
+            return {
+                action: protocol.action,
+                completion: "service",
                 projectServiceJson: (serviceJson) => command.projectService(command.decodeService(JSON.parse(serviceJson))),
-                projectChild: (child) => {
-                    if (command.projectChild === undefined)
-                        throw new Error(`request ${command.action} has no child reference codec`);
-                    return command.projectChild(child);
+                resolve: (payload) => {
+                    const input = protocol.decodeRequest(payload);
+                    if (input === null)
+                        return null;
+                    return {
+                        payloadJson: JSON.stringify(protocol.encodeRequest(input)),
+                        isPermitted: (allowed) => protocol.isPermitted(allowed),
+                        execute: async (facts) => {
+                            const served = await command.execute(input, facts);
+                            return {
+                                result: protocol.encodeResult(served.result),
+                                serviceJson: JSON.stringify(command.encodeService(served.service)),
+                            };
+                        },
+                        encodeFailure: (error) => protocol.encodeFailure?.(error) ?? null,
+                    };
                 },
             };
-        },
-    };
+    }
+}
+export function composeRequestCommands(...maps) {
+    const commands = Object.create(null);
+    for (const map of maps) {
+        for (const [action, command] of Object.entries(map)) {
+            if (Object.hasOwn(commands, action))
+                throw new Error(`duplicate request command action: ${action}`);
+            commands[action] = command;
+        }
+    }
+    return commands;
 }
 export function decodeEnvelope(bytes, fileId) {
     let decoded;
@@ -89,10 +126,12 @@ export function requestPath(directory, id) {
 export function receiptPath(directory, id) {
     return join(directory, `${id}.receipt.json`);
 }
-export async function atomicJson(path, value) {
+export async function atomicJson(path, value, signal, beforeRename) {
     const temporary = `${path}.${randomUUID()}.tmp`;
     try {
         await writeFile(temporary, `${JSON.stringify(value)}\n`, { flag: "wx" });
+        await beforeRename?.();
+        signal?.throwIfAborted();
         await rename(temporary, path);
     }
     finally {

package/build/src/akuma/turn-drive.d.ts

@@ -1,8 +1,8 @@
 import { type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
-import type { AkumaCallRequestChildLaunch } from "./call-request.js";
-import type { ErasedRequestCommand } from "./request-wire.js";
+import { type AkumaCallRequestChildLaunch } from "./call-request.js";
+import { type ErasedRequestCommand } from "./request-wire.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
 export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
@@ -25,10 +25,11 @@ export type DriveTurnInput = Readonly<{
     body: string;
     call?: string;
     launchTells: readonly TellFact[];
+    schemaJson?: string;
     supervisor: BodySupervisor;
     runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
-    upstream?: unknown;
-    commands: Readonly<Record<string, ErasedRequestCommand>>;
+    world: import("../world.js").WorldRoot;
+    externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
     now(): string;
 }>;
 export declare function driveTurn(input: DriveTurnInput): Promise<(DrivenTurn & Readonly<{

package/build/src/akuma/turn-drive.js

@@ -1,8 +1,10 @@
 import { abortableDelay } from "./abort.js";
 /* eslint-disable max-lines-per-function -- Turn setup and consumption each preserve one ordered lifecycle transaction. */
-import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { appendActivity, beginTurn, bindTellsToTurn, breakBody, drainPendingTells, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
 import { encodeAgentEvent, } from "./provider.js";
+import { akumaCallRequestCommands } from "./call-request.js";
 import { BodyRequestPump } from "./request-serve.js";
+import { composeRequestCommands } from "./request-wire.js";
 import { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function serializeEffects() {
     let tail = Promise.resolve();
@@ -68,19 +70,29 @@ async function startTurnDrive(input) {
     const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
     if (session !== undefined && input.adapter.resume === undefined)
         return { kind: "resume-unsupported" };
+    const boundTells = drainPendingTells(input.launchTells);
+    const schemaJson = input.schemaJson ?? boundTells.find((tell) => tell.schemaJson !== undefined)?.schemaJson;
     const turn = await beginTurn(input.paths, {
         bodySequence: input.bodySequence,
         startedAt: input.now(),
         ...(input.call === undefined ? {} : { call: input.call }),
+        ...(schemaJson === undefined ? {} : { schemaJson }),
     });
+    if (boundTells.length > 0) {
+        await bindTellsToTurn(input.paths, {
+            turnSequence: turn.sequence,
+            tellIds: boundTells.map((tell) => tell.id),
+            boundAt: input.now(),
+        });
+    }
+    const { world, paths, soul: parent, runtimeSpawn: spawn, externalCommands } = input;
+    const commands = composeRequestCommands(akumaCallRequestCommands({ world, paths, parent, spawn }), externalCommands);
     const requests = await BodyRequestPump.open({
         paths: input.paths,
-        parent: input.soul,
+        allowed: input.soul.allowed,
         bodySequence: input.bodySequence,
         now: input.now,
-        spawn: input.runtimeSpawn,
-        ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
-        commands: input.commands,
+        commands,
         signal: input.supervisor.signal,
     });
     const driveController = new AbortController();
@@ -97,11 +109,12 @@ async function startTurnDrive(input) {
     });
     const driveInput = {
         body: input.body,
-        launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
+        launchTells: boundTells.map((tell) => ({ id: tell.id, text: tell.body })),
         cwd,
         options,
         signal: driveController.signal,
         requests: { dir: requests.directory },
+        ...(schemaJson === undefined ? {} : { schemaJson }),
     };
     const attempt = session === undefined
         ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
@@ -121,8 +134,8 @@ async function startTurnDrive(input) {
             }
             return { kind: "stopped" };
         }
-        if (input.launchTells.length > 0)
-            await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
+        if (boundTells.length > 0)
+            await recordTellDeliveries(input.paths, boundTells.map((tell) => ({
                 tellId: tell.id,
                 route: "launch",
                 turnSequence: turn.sequence,
@@ -226,13 +239,14 @@ function observeCompletionFailure(drive) {
 async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
     const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
     for (const tell of pending) {
-        if (attempted.has(tell.id))
+        if (attempted.has(tell.id) || tell.schemaJson !== undefined)
             continue;
         attempted.add(tell.id);
         const outcome = await writeWitness(async () => {
             const submission = await tellLive({ id: tell.id, text: tell.body });
             if (!mayWrite() || submission.kind === "turn-ended")
                 return "turn-ended";
+            await bindTellsToTurn(input.paths, { turnSequence, tellIds: [tell.id], boundAt: input.now() });
             await recordTellDeliveries(input.paths, [
                 {
                     tellId: tell.id,
@@ -261,7 +275,9 @@ async function stopActiveDrive(input, active) {
     }
 }
 function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
-    return liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id));
+    return (liveTells &&
+        tellPump === null &&
+        pending.some((tell) => !attempted.has(tell.id) && tell.schemaJson === undefined));
 }
 async function settleCompletion(result, session, active) {
     try {
@@ -276,7 +292,7 @@ async function consumeTurnDrive(input, active) {
     const { turnSequence, drive, requests, resume } = active;
     let heart = input.supervisor.current();
     let turnSession = resume;
-    const attempted = new Set(input.launchTells.map((tell) => tell.id));
+    const attempted = new Set(drainPendingTells(input.launchTells).map((tell) => tell.id));
     const writeWitness = serializeEffects();
     let writesOpen = true;
     const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;

package/build/src/akuma-body.d.ts

@@ -1,13 +1,11 @@
 import { type BodyLaunch } from "./akuma/body.js";
-import { type WorldRoot } from "./world.js";
-import { type FleetRequestPort } from "./library/fleet.js";
-import { type ContractRequestPort } from "./library/contract-operations.js";
-import { type TaskMutationRequestPort } from "./task/mutation.js";
+import { World } from "./world.js";
 type BodyProcessConfiguration = Readonly<{
     home?: string;
     gitPath?: string;
 }>;
-export declare function upstreamFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): Promise<FleetRequestPort & ContractRequestPort & TaskMutationRequestPort & Readonly<{
-    launchWorld(): WorldRoot;
+export declare function externalRequestCommandsFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): Promise<Readonly<{
+    world: Awaited<ReturnType<typeof World.prove>>;
+    commands: Readonly<Record<string, import("./akuma/request-wire.js").ErasedRequestCommand>>;
 }>>;
 export {};

package/build/src/akuma-body.js

@@ -1,14 +1,14 @@
 import { LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
-import { akumaCallRequestCommands } from "./akuma/call-request.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
 import { World } from "./world.js";
-import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "./library/fleet.js";
-import { fleetRequestCommands } from "./library/fleet.js";
-import { requireBranchesToBeUpToDateFrom, worktreeHooksFrom } from "./library/configuration.js";
+import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "./akuma/fleet-execution.js";
+import { fleetRequestCommands } from "./akuma/fleet-request.js";
+import { worktreeHooksFrom } from "./git/hooks.js";
 import { contractRequestCommands, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./library/contract-operations.js";
 import { Repo } from "./library/repo.js";
-import { settings } from "./settings.js";
+import { requireBranchesToBeUpToDateFrom, settings } from "./settings.js";
 import { executeTaskMutation, taskMutationRequestCommands } from "./task/mutation.js";
+import { composeRequestCommands } from "./akuma/request-wire.js";
 async function contractDependencies(repoRoot, processConfiguration) {
     const repo = await Repo.at({
         path: repoRoot,
@@ -65,11 +65,8 @@ function contractUpstream(processConfiguration) {
         },
     };
 }
-export async function upstreamFor(launch, processConfiguration) {
-    const world = await World.prove(worldRootForAkumaPaths(launch.paths));
+function fleetRequestPort(world) {
     return {
-        launchWorld: () => world,
-        ...contractUpstream(processConfiguration),
         wait: async (input) => await executeWaitAkuma({
             path: world,
             ids: input.targets,
@@ -89,6 +86,10 @@ export async function upstreamFor(launch, processConfiguration) {
             const result = await executeKillAkuma({ path: world, ids: input.targets, signal: input.signal });
             return result;
         },
+    };
+}
+function taskMutationRequestPort() {
+    return {
         task: async (input) => await executeTaskMutation({
             world: input.world,
             request: input.request,
@@ -110,12 +111,13 @@ const configuration = {
     ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
     ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
 };
-const upstream = await upstreamFor(launch, configuration);
-const commands = {
-    ...akumaCallRequestCommands(),
-    ...fleetRequestCommands(),
-    ...contractRequestCommands(),
-    ...taskMutationRequestCommands(),
-};
-if ((await runAkumaBody(launch, upstream, commands)) === "held")
+export async function externalRequestCommandsFor(launch, processConfiguration) {
+    const world = await World.prove(worldRootForAkumaPaths(launch.paths));
+    return {
+        world,
+        commands: composeRequestCommands(fleetRequestCommands(fleetRequestPort(world)), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
+    };
+}
+const { world, commands: externalCommands } = await externalRequestCommandsFor(launch, configuration);
+if ((await runAkumaBody(launch, world, externalCommands)) === "held")
     process.exitCode = LEASH_HELD_EXIT;

package/build/src/bounded-list.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_BOUNDED_LIST_LIMIT = 50;
+export declare const MAX_BOUNDED_LIST_LIMIT = 500;
+export type BoundedList<Row> = Readonly<{
+    rows: readonly Row[];
+    hasMore: boolean;
+}>;
+export declare function boundedListLimit(value?: unknown): number;
+export declare function projectBoundedList<Row>(rows: readonly Row[], limit: number): BoundedList<Row>;