@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/akuma/fleet-execution.js

@@ -0,0 +1,109 @@
+import { Akuma, AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
+import { readBudgetedStatus, tellAkumaWithId } from "./akuma.js";
+import { NO_DISPATCH_ASSOCIATION } from "../dispatch/association.js";
+import { EMPTY_CREATED_TASK_OBSERVATION } from "../task/created-observation.js";
+import { fleetResultSchemas, parseAkumaObservation, } from "./fleet-observation.js";
+function source(path) {
+    return Akuma.of(path);
+}
+function observationDiagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const SHARED_ORDINARY_BUDGET = 30;
+const POLL_MS = 100;
+function akumaOnlyObservation(status) {
+    return parseAkumaObservation({
+        status,
+        contract: NO_DISPATCH_ASSOCIATION,
+        createdTasks: EMPTY_CREATED_TASK_OBSERVATION,
+    });
+}
+async function observeWaitRound(path, ids, signal) {
+    signal?.throwIfAborted();
+    if (ids.length <= 1) {
+        return {
+            statuses: await Promise.all(ids.map(async (id) => await source(path).of({ id }).status())),
+            unobserved: [],
+        };
+    }
+    let remaining = SHARED_ORDINARY_BUDGET;
+    const statuses = [];
+    const unobserved = [];
+    for (const id of ids) {
+        signal?.throwIfAborted();
+        try {
+            const observed = await readBudgetedStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
+            statuses.push(observed.status);
+            remaining -= observed.ordinarySelected;
+        }
+        catch (error) {
+            if (error instanceof AkumaNotBornError)
+                throw error;
+            unobserved.push({ id, diagnostic: observationDiagnostic(error) });
+        }
+    }
+    return { statuses, unobserved };
+}
+function delay(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        let timer;
+        const done = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            reject(signal?.reason ?? new Error("upstream request aborted"));
+        };
+        timer = setTimeout(done, milliseconds);
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+export async function executeWaitAkuma(input) {
+    const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
+    for (;;) {
+        const round = await observeWaitRound(input.path, input.ids, input.signal);
+        const settled = round.statuses.map(defaultWaitComplete);
+        const completed = round.statuses.length > 0 &&
+            (input.completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean));
+        if (completed || (deadline !== undefined && performance.now() >= deadline)) {
+            return fleetResultSchemas.wait.parse({
+                completion: input.completion,
+                observations: round.statuses.map(akumaOnlyObservation),
+                unobserved: round.unobserved,
+            });
+        }
+        await delay(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
+    }
+}
+export async function executeTellAkuma(input) {
+    input.signal?.throwIfAborted();
+    const handle = source(input.path).of({ id: input.id });
+    const tell = input.tellId === undefined
+        ? await handle.tell(input.body)
+        : await tellAkumaWithId({
+            worldPath: input.path,
+            id: input.id,
+            body: input.body,
+            tellId: input.tellId,
+            ...(input.recordedAt === undefined ? {} : { recordedAt: input.recordedAt }),
+        });
+    input.signal?.throwIfAborted();
+    return fleetResultSchemas.tell.parse({
+        akuma: input.id,
+        tell,
+    });
+}
+export async function executeKillAkuma(input) {
+    input.signal?.throwIfAborted();
+    const handles = input.ids.map((id) => source(input.path).of({ id }));
+    const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
+    input.signal?.throwIfAborted();
+    return fleetResultSchemas.kill.parse({
+        results: input.ids.map((id, index) => ({ id, evidence: evidence[index] })),
+    });
+}

package/build/src/{library/fleet-result.d.ts → akuma/fleet-observation.d.ts}

@@ -1,48 +1,7 @@
 import { z } from "zod";
-declare const dispatchAssociationSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"none">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"associated">;
-    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"failed">;
-    diagnostic: z.ZodString;
-}, z.core.$strict>]>;
-declare const createdTaskObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"present">;
-    rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-        title: z.ZodString;
-        state: z.ZodEnum<{
-            open: "open";
-            in_progress: "in_progress";
-            on_hold: "on_hold";
-            done: "done";
-            drop: "drop";
-        }>;
-        priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-        disposition: z.ZodEnum<{
-            in_progress: "in_progress";
-            on_hold: "on_hold";
-            done: "done";
-            drop: "drop";
-            ready: "ready";
-            blocked: "blocked";
-        }>;
-        updatedAt: z.ZodString;
-        bodyPresent: z.ZodBoolean;
-        children: z.ZodOptional<z.ZodObject<{
-            live: z.ZodNumber;
-            total: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"failed">;
-    diagnostic: z.ZodString;
-}, z.core.$strict>]>;
 declare const akumaObservationSchema: z.ZodObject<{
     status: z.ZodObject<{
-        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         life: z.ZodEnum<{
             killed: "killed";
             hung: "hung";
@@ -429,7 +388,7 @@ declare const akumaObservationSchema: z.ZodObject<{
         kind: z.ZodLiteral<"none">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"associated">;
-        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"failed">;
         diagnostic: z.ZodString;
@@ -468,7 +427,7 @@ declare const akumaObservationSchema: z.ZodObject<{
     }, z.core.$strict>]>;
 }, z.core.$strict>;
 declare const akumaUnobservedSchema: z.ZodObject<{
-    id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     diagnostic: z.ZodString;
 }, z.core.$strict>;
 declare const akumaWaitResultSchema: z.ZodObject<{
@@ -478,7 +437,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
     }>;
     observations: z.ZodArray<z.ZodObject<{
         status: z.ZodObject<{
-            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
             life: z.ZodEnum<{
                 killed: "killed";
                 hung: "hung";
@@ -865,7 +824,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
             kind: z.ZodLiteral<"none">;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"associated">;
-            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"failed">;
             diagnostic: z.ZodString;
@@ -904,13 +863,13 @@ declare const akumaWaitResultSchema: z.ZodObject<{
         }, z.core.$strict>]>;
     }, z.core.$strict>>;
     unobserved: z.ZodArray<z.ZodObject<{
-        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         diagnostic: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 declare const akumaKillResultSchema: z.ZodObject<{
     results: z.ZodArray<z.ZodObject<{
-        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         evidence: z.ZodEnum<{
             unavailable: "unavailable";
             killed: "killed";
@@ -922,7 +881,7 @@ declare const akumaKillResultSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 declare const akumaTellResultSchema: z.ZodObject<{
-    akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+    akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     tell: z.ZodObject<{
         admission: z.ZodObject<{
             fact: z.ZodLiteral<"recorded">;
@@ -1010,8 +969,6 @@ declare const akumaTellResultSchema: z.ZodObject<{
         }>>]>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export type CreatedTaskObservation = z.infer<typeof createdTaskObservationSchema>;
-export type DispatchAssociation = z.infer<typeof dispatchAssociationSchema>;
 export type AkumaObservation = z.infer<typeof akumaObservationSchema>;
 export type AkumaObservationStage = (Readonly<{
     kind: "observed";
@@ -1023,7 +980,6 @@ export type AkumaUnobserved = z.infer<typeof akumaUnobservedSchema>;
 export type AkumaWaitResult = z.infer<typeof akumaWaitResultSchema>;
 export type AkumaKillResult = z.infer<typeof akumaKillResultSchema>;
 export type AkumaTellResult = z.infer<typeof akumaTellResultSchema>;
-export declare function parseCreatedTaskObservation(value: unknown): CreatedTaskObservation;
 export declare function parseAkumaObservation(value: unknown): AkumaObservation;
 export declare function isWaitResult(value: unknown): value is AkumaWaitResult;
 export declare function isKillResult(value: unknown): value is AkumaKillResult;
@@ -1036,7 +992,7 @@ export declare const fleetResultSchemas: {
         }>;
         observations: z.ZodArray<z.ZodObject<{
             status: z.ZodObject<{
-                id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+                id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
                 life: z.ZodEnum<{
                     killed: "killed";
                     hung: "hung";
@@ -1423,7 +1379,7 @@ export declare const fleetResultSchemas: {
                 kind: z.ZodLiteral<"none">;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"associated">;
-                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"failed">;
                 diagnostic: z.ZodString;
@@ -1462,12 +1418,12 @@ export declare const fleetResultSchemas: {
             }, z.core.$strict>]>;
         }, z.core.$strict>>;
         unobserved: z.ZodArray<z.ZodObject<{
-            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
             diagnostic: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
     tell: z.ZodObject<{
-        akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+        akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         tell: z.ZodObject<{
             admission: z.ZodObject<{
                 fact: z.ZodLiteral<"recorded">;
@@ -1557,7 +1513,7 @@ export declare const fleetResultSchemas: {
     }, z.core.$strict>;
     kill: z.ZodObject<{
         results: z.ZodArray<z.ZodObject<{
-            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
             evidence: z.ZodEnum<{
                 unavailable: "unavailable";
                 killed: "killed";

package/build/src/{library/fleet-result.js → akuma/fleet-observation.js}

@@ -1,18 +1,9 @@
-import { akumaIdSchema, akumaStatusSchema } from "../akuma/akuma.js";
-import { tellRowSchema } from "../akuma/projection.js";
-import { contractId } from "../core/facts/types.js";
-import { taskRowsSchema } from "../task/board.js";
+import { akumaIdSchema, akumaStatusSchema } from "./akuma.js";
+import { tellRowSchema } from "./projection.js";
+import { dispatchAssociationSchema } from "../dispatch/association.js";
+import { createdTaskObservationSchema } from "../task/created-observation.js";
 import { z } from "zod";
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
-const contractIdSchema = z.string().transform((value, context) => {
-    try {
-        return contractId(value);
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected ContractId" });
-        return z.NEVER;
-    }
-});
 const killEvidenceSchema = z.enum([
     "killed",
     "already-killed",
@@ -21,15 +12,6 @@ const killEvidenceSchema = z.enum([
     "untidy",
     "unavailable",
 ]);
-const dispatchAssociationSchema = z.union([
-    z.object({ kind: z.literal("none") }).strict(),
-    z.object({ kind: z.literal("associated"), contractId: contractIdSchema }).strict(),
-    z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
-]);
-const createdTaskObservationSchema = z.union([
-    z.object({ kind: z.literal("present"), rows: taskRowsSchema }).strict(),
-    z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
-]);
 const akumaObservationSchema = z
     .object({
     status: akumaStatusSchema,
@@ -75,9 +57,6 @@ const akumaWaitResultSchema = z
     .strict();
 const akumaKillResultSchema = z.object({ results: z.array(akumaKillResultItemSchema) }).strict();
 const akumaTellResultSchema = z.object({ akuma: akumaIdSchema, tell: tellResultSchema }).strict();
-export function parseCreatedTaskObservation(value) {
-    return createdTaskObservationSchema.parse(value);
-}
 export function parseAkumaObservation(value) {
     return akumaObservationSchema.parse(value);
 }

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

@@ -0,0 +1,122 @@
+import type { KillEvidence } from "./heart/index.js";
+import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCommand } from "./request-wire.js";
+import type { AkumaStatus } from "./akuma.js";
+import { type AkumaKillResult, type AkumaTellResult, type AkumaWaitResult } from "./fleet-observation.js";
+import { z } from "zod";
+declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
+    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>;
+    completion: z.ZodEnum<{
+        any: "any";
+        all: "all";
+    }>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    timeoutMs?: number;
+    targets: import("./identity.js").AkuId[];
+    completion: "any" | "all";
+    action: "akuma.wait";
+}, {
+    targets: import("./identity.js").AkuId[];
+    completion: "any" | "all";
+    timeoutMs?: number | undefined;
+}>>;
+declare const tellRequestSchema: z.ZodPipe<z.ZodObject<{
+    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+    body: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    target: import("./identity.js").AkuId;
+    body: string;
+    action: "akuma.tell";
+}, {
+    target: import("./identity.js").AkuId;
+    body: string;
+}>>;
+declare const killRequestSchema: z.ZodPipe<z.ZodObject<{
+    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>;
+}, z.core.$strict>, z.ZodTransform<{
+    targets: import("./identity.js").AkuId[];
+    action: "akuma.kill";
+}, {
+    targets: import("./identity.js").AkuId[];
+}>>;
+declare const waitServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.wait">;
+}, z.core.$strict>;
+declare const tellServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.tell">;
+    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+    tellId: z.ZodString;
+}, z.core.$strict>;
+declare const killServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.kill">;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+        evidence: z.ZodEnum<{
+            unavailable: "unavailable";
+            killed: "killed";
+            "already-killed": "already-killed";
+            "already-stopped": "already-stopped";
+            hung: "hung";
+            untidy: "untidy";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FleetRequest = (Omit<z.infer<typeof waitRequestSchema>, "targets"> & Readonly<{
+    targets: readonly AkumaStatus["id"][];
+}>) | z.infer<typeof tellRequestSchema> | (Omit<z.infer<typeof killRequestSchema>, "targets"> & Readonly<{
+    targets: readonly AkumaStatus["id"][];
+}>);
+export type FleetService = z.infer<typeof waitServiceSchema> | z.infer<typeof tellServiceSchema> | (Omit<z.infer<typeof killServiceSchema>, "results"> & Readonly<{
+    results: readonly Readonly<{
+        id: AkumaStatus["id"];
+        evidence: KillEvidence;
+    }>[];
+}>);
+export type FleetRequestPort = Readonly<{
+    wait(input: Readonly<{
+        targets: readonly AkumaStatus["id"][];
+        completion: "any" | "all";
+        timeoutMs?: number;
+        signal: AbortSignal;
+    }>): Promise<AkumaWaitResult>;
+    tell(input: Readonly<{
+        target: AkumaStatus["id"];
+        body: string;
+        tellId: string;
+        recordedAt: string;
+        signal: AbortSignal;
+    }>): Promise<AkumaTellResult>;
+    kill(input: Readonly<{
+        targets: readonly AkumaStatus["id"][];
+        signal: AbortSignal;
+    }>): Promise<AkumaKillResult | Readonly<{
+        result: unknown;
+        service: readonly Readonly<{
+            id: AkumaStatus["id"];
+            evidence: KillEvidence;
+        }>[];
+    }>>;
+}>;
+/** Akuma owns Body Request payload, live result, and durable service codecs for wait/tell/kill. */
+export declare function fleetRequestProtocol(action: FleetRequest["action"]): RequestProtocol<FleetRequest, unknown, FleetService>;
+export declare function fleetRequestCommand(action: FleetRequest["action"], port: FleetRequestPort): ServiceRequestCommand<FleetRequest, unknown, FleetService, FleetService>;
+export declare function fleetRequestCommands(port: FleetRequestPort): Readonly<Record<"akuma.wait" | "akuma.tell" | "akuma.kill", ErasedRequestCommand>>;
+export declare function requestForwardedFleetWait(input: Readonly<{
+    directory: string;
+    targets: readonly AkumaStatus["id"][];
+    completion: "any" | "all";
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}>): Promise<AkumaWaitResult>;
+export declare function requestForwardedFleetTell(input: Readonly<{
+    directory: string;
+    target: AkumaStatus["id"];
+    body: string;
+    signal?: AbortSignal;
+}>): Promise<AkumaTellResult>;
+export declare function requestForwardedFleetKill(input: Readonly<{
+    directory: string;
+    targets: readonly AkumaStatus["id"][];
+    signal?: AbortSignal;
+}>): Promise<AkumaKillResult>;
+export {};

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

@@ -0,0 +1,168 @@
+import { akumaIdSchema } from "./akuma.js";
+import { requestBodyCommand } from "./request-rendezvous.js";
+import { eraseRequestCommand, } from "./request-wire.js";
+import { fleetResultSchemas, isKillResult, isTellResult, isWaitResult, } from "./fleet-observation.js";
+import { z } from "zod";
+const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+const fleetTargetsSchema = z
+    .array(akumaIdSchema)
+    .min(1)
+    .superRefine((ids, context) => {
+    if (ids.some((id, index) => index > 0 && ids[index - 1] >= id))
+        context.addIssue({ code: "custom", message: "expected a strictly ordered target set" });
+});
+const waitRequestSchema = z
+    .object({
+    targets: fleetTargetsSchema,
+    completion: z.enum(["any", "all"]),
+    timeoutMs: z.number().int().nonnegative().optional(),
+})
+    .strict()
+    .transform(({ timeoutMs, ...request }) => ({
+    action: "akuma.wait",
+    ...request,
+    ...(timeoutMs === undefined ? {} : { timeoutMs }),
+}));
+const tellRequestSchema = z
+    .object({ target: akumaIdSchema, body: z.string() })
+    .strict()
+    .transform((request) => ({ action: "akuma.tell", ...request }));
+const killRequestSchema = z
+    .object({ targets: fleetTargetsSchema })
+    .strict()
+    .transform((request) => ({ action: "akuma.kill", ...request }));
+const waitServiceSchema = z.object({ action: z.literal("akuma.wait") }).strict();
+const tellServiceSchema = z
+    .object({ action: z.literal("akuma.tell"), target: akumaIdSchema, tellId: nonblankTextSchema })
+    .strict();
+const killServiceSchema = z
+    .object({
+    action: z.literal("akuma.kill"),
+    results: z.array(z.object({ id: akumaIdSchema, evidence: fleetResultSchemas.killEvidence }).strict()),
+})
+    .strict();
+function decodeFleetRequest(action, value) {
+    const schema = action === "akuma.wait" ? waitRequestSchema : action === "akuma.tell" ? tellRequestSchema : killRequestSchema;
+    const parsed = schema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function decodeFleetService(action, value) {
+    const schema = action === "akuma.wait" ? waitServiceSchema : action === "akuma.tell" ? tellServiceSchema : killServiceSchema;
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new Error("malformed stored Fleet service evidence");
+    return parsed.data;
+}
+function decodedFleetResult(action, value) {
+    const schema = action === "akuma.wait"
+        ? fleetResultSchemas.wait
+        : action === "akuma.tell"
+            ? fleetResultSchemas.tell
+            : fleetResultSchemas.kill;
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new Error(`Akuma body request returned an invalid live result for ${action}`);
+    return parsed.data;
+}
+/** Akuma owns Body Request payload, live result, and durable service codecs for wait/tell/kill. */
+export function fleetRequestProtocol(action) {
+    return {
+        action,
+        encodeRequest: (request) => {
+            const { action: _action, ...payload } = request;
+            return payload;
+        },
+        decodeRequest: (payload) => decodeFleetRequest(action, payload),
+        encodeResult: (result) => result,
+        decodeResult: (result) => decodedFleetResult(action, result),
+        decodeReference: (reference) => decodeFleetService(action, reference),
+        isPermitted: (allowed) => action === "akuma.wait" || allowed.includes(action),
+    };
+}
+export function fleetRequestCommand(action, port) {
+    return {
+        completion: "service",
+        protocol: fleetRequestProtocol(action),
+        encodeService: (service) => decodeFleetService(action, service),
+        decodeService: (service) => decodeFleetService(action, service),
+        projectService: (service) => decodeFleetService(action, service),
+        execute: async (request, facts) => {
+            if (request.action === "akuma.wait") {
+                return {
+                    result: await port.wait({ ...request, signal: facts.signal }),
+                    service: { action: request.action },
+                };
+            }
+            if (request.action === "akuma.tell") {
+                return {
+                    result: await port.tell({
+                        target: request.target,
+                        body: request.body,
+                        tellId: facts.id,
+                        recordedAt: facts.admittedAt,
+                        signal: facts.signal,
+                    }),
+                    service: { action: request.action, target: request.target, tellId: facts.id },
+                };
+            }
+            const result = await port.kill({ targets: request.targets, signal: facts.signal });
+            if ("result" in result)
+                return { result: result.result, service: { action: request.action, results: result.service } };
+            return {
+                result,
+                service: { action: request.action, results: result.results.map(({ id, evidence }) => ({ id, evidence })) },
+            };
+        },
+    };
+}
+export function fleetRequestCommands(port) {
+    return {
+        "akuma.wait": eraseRequestCommand(fleetRequestCommand("akuma.wait", port)),
+        "akuma.tell": eraseRequestCommand(fleetRequestCommand("akuma.tell", port)),
+        "akuma.kill": eraseRequestCommand(fleetRequestCommand("akuma.kill", port)),
+    };
+}
+function forwardedFleetCommandResult(response, action) {
+    if (response.kind === "returned") {
+        if (action === "akuma.wait" && isWaitResult(response.result))
+            return response.result;
+        if (action === "akuma.tell" && isTellResult(response.result))
+            return response.result;
+        if (action === "akuma.kill" && isKillResult(response.result))
+            return response.result;
+        throw new Error(`transport integrity: request Fleet ${action} returned an invalid live result`);
+    }
+    throw new Error("Akuma body request terminal Fleet reference cannot reproduce an expired live result");
+}
+export async function requestForwardedFleetWait(input) {
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        command: fleetRequestProtocol("akuma.wait"),
+        value: {
+            action: "akuma.wait",
+            targets: input.targets,
+            completion: input.completion,
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+        },
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    return forwardedFleetCommandResult(response, "akuma.wait");
+}
+export async function requestForwardedFleetTell(input) {
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        command: fleetRequestProtocol("akuma.tell"),
+        value: { action: "akuma.tell", target: input.target, body: input.body },
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    return forwardedFleetCommandResult(response, "akuma.tell");
+}
+export async function requestForwardedFleetKill(input) {
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        command: fleetRequestProtocol("akuma.kill"),
+        value: { action: "akuma.kill", targets: input.targets },
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    return forwardedFleetCommandResult(response, "akuma.kill");
+}