@astrosheep/keiyaku 4.5.26 → 4.5.28

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

@@ -10,6 +10,7 @@ declare const akumaObservationSchema: z.ZodObject<{
             asleep: "asleep";
             stranded: "stranded";
         }>;
+        cwd: z.ZodOptional<z.ZodString>;
         allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
             "task.add": "task.add";
             "task.addDocument": "task.addDocument";
@@ -185,6 +186,10 @@ declare const akumaObservationSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"other">;
                         display: z.ZodString;
+                        input: z.ZodOptional<z.ZodObject<{
+                            json: z.ZodString;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>]>;
                     state: z.ZodLiteral<"active">;
                     truncated: z.ZodOptional<z.ZodLiteral<true>>;
@@ -232,6 +237,10 @@ declare const akumaObservationSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"other">;
                         display: z.ZodString;
+                        input: z.ZodOptional<z.ZodObject<{
+                            json: z.ZodString;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>]>;
                     state: z.ZodObject<{
                         status: z.ZodEnum<{
@@ -387,6 +396,10 @@ declare const akumaObservationSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"other">;
                         display: z.ZodString;
+                        input: z.ZodOptional<z.ZodObject<{
+                            json: z.ZodString;
+                            truncated: z.ZodBoolean;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>]>;
                     state: z.ZodObject<{
                         status: z.ZodEnum<{
@@ -469,6 +482,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                 asleep: "asleep";
                 stranded: "stranded";
             }>;
+            cwd: z.ZodOptional<z.ZodString>;
             allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
                 "task.add": "task.add";
                 "task.addDocument": "task.addDocument";
@@ -644,6 +658,10 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"other">;
                             display: z.ZodString;
+                            input: z.ZodOptional<z.ZodObject<{
+                                json: z.ZodString;
+                                truncated: z.ZodBoolean;
+                            }, z.core.$strict>>;
                         }, z.core.$strict>]>;
                         state: z.ZodLiteral<"active">;
                         truncated: z.ZodOptional<z.ZodLiteral<true>>;
@@ -691,6 +709,10 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"other">;
                             display: z.ZodString;
+                            input: z.ZodOptional<z.ZodObject<{
+                                json: z.ZodString;
+                                truncated: z.ZodBoolean;
+                            }, z.core.$strict>>;
                         }, z.core.$strict>]>;
                         state: z.ZodObject<{
                             status: z.ZodEnum<{
@@ -846,6 +868,10 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"other">;
                             display: z.ZodString;
+                            input: z.ZodOptional<z.ZodObject<{
+                                json: z.ZodString;
+                                truncated: z.ZodBoolean;
+                            }, z.core.$strict>>;
                         }, z.core.$strict>]>;
                         state: z.ZodObject<{
                             status: z.ZodEnum<{
@@ -1011,6 +1037,106 @@ declare const akumaTellResultSchema: z.ZodObject<{
         }>>]>;
     }, z.core.$strict>;
 }, z.core.$strict>;
+declare const akumaTellWaitResultSchema: z.ZodObject<{
+    akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+    tell: z.ZodObject<{
+        admission: z.ZodObject<{
+            fact: z.ZodLiteral<"recorded">;
+            tellId: z.ZodString;
+        }, z.core.$strict>;
+        row: z.ZodObject<{
+            kind: z.ZodLiteral<"tell">;
+            sequence: z.ZodNumber;
+            at: z.ZodString;
+            tellId: z.ZodString;
+            text: z.ZodString;
+            state: z.ZodEnum<{
+                pending: "pending";
+                told: "told";
+            }>;
+            deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                deliveredAt: z.ZodString;
+                route: z.ZodEnum<{
+                    live: "live";
+                    launch: "launch";
+                }>;
+                turnSequence: z.ZodNumber;
+                receipt: z.ZodOptional<z.ZodEnum<{
+                    required: "required";
+                    unavailable: "unavailable";
+                }>>;
+            }, z.core.$strict>, z.ZodTransform<Readonly<{
+                turnSequence: number;
+                route: "launch" | "live";
+                receipt?: "unavailable" | "required";
+                deliveredAt: string;
+            }>, {
+                deliveredAt: string;
+                route: "live" | "launch";
+                turnSequence: number;
+                receipt?: "required" | "unavailable" | undefined;
+            }>>>>;
+        }, z.core.$strict>;
+        wake: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"told">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"held">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pursuing">;
+            bodySequence: z.ZodNumber;
+        }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            diagnostic: z.ZodString;
+            child: z.ZodOptional<z.ZodObject<{
+                code: z.ZodNullable<z.ZodNumber>;
+                signal: z.ZodNullable<z.ZodString>;
+                log: z.ZodObject<{
+                    path: z.ZodString;
+                    from: z.ZodNumber;
+                    to: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodTransform<{
+            kind: "failed";
+            diagnostic: string;
+        } | {
+            child: {
+                code: number | null;
+                signal: string | null;
+                log: {
+                    path: string;
+                    from: number;
+                    to: number;
+                };
+            };
+            kind: "failed";
+            diagnostic: string;
+        }, {
+            kind: "failed";
+            diagnostic: string;
+            child?: {
+                code: number | null;
+                signal: string | null;
+                log: {
+                    path: string;
+                    from: number;
+                    to: number;
+                };
+            } | undefined;
+        }>>]>;
+    }, z.core.$strict>;
+    observation: z.ZodUnion<readonly [z.ZodObject<{
+        reason: z.ZodLiteral<"answered">;
+        answer: z.ZodUnknown;
+    }, z.core.$strict>, z.ZodObject<{
+        reason: z.ZodLiteral<"failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        reason: z.ZodLiteral<"unanswered">;
+    }, z.core.$strict>, z.ZodObject<{
+        reason: z.ZodLiteral<"deadline">;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
 export type AkumaObservation = z.infer<typeof akumaObservationSchema>;
 export type AkumaObservationStage = (Readonly<{
     kind: "observed";
@@ -1022,10 +1148,12 @@ 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 type AkumaTellWaitResult = z.infer<typeof akumaTellWaitResultSchema>;
 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;
 export declare function isTellResult(value: unknown): value is AkumaTellResult;
+export declare function isTellWaitResult(value: unknown): value is AkumaTellWaitResult;
 export declare const fleetResultSchemas: {
     wait: z.ZodObject<{
         mode: z.ZodEnum<{
@@ -1047,6 +1175,7 @@ export declare const fleetResultSchemas: {
                     asleep: "asleep";
                     stranded: "stranded";
                 }>;
+                cwd: z.ZodOptional<z.ZodString>;
                 allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
                     "task.add": "task.add";
                     "task.addDocument": "task.addDocument";
@@ -1222,6 +1351,10 @@ export declare const fleetResultSchemas: {
                             }, z.core.$strict>, z.ZodObject<{
                                 kind: z.ZodLiteral<"other">;
                                 display: z.ZodString;
+                                input: z.ZodOptional<z.ZodObject<{
+                                    json: z.ZodString;
+                                    truncated: z.ZodBoolean;
+                                }, z.core.$strict>>;
                             }, z.core.$strict>]>;
                             state: z.ZodLiteral<"active">;
                             truncated: z.ZodOptional<z.ZodLiteral<true>>;
@@ -1269,6 +1402,10 @@ export declare const fleetResultSchemas: {
                             }, z.core.$strict>, z.ZodObject<{
                                 kind: z.ZodLiteral<"other">;
                                 display: z.ZodString;
+                                input: z.ZodOptional<z.ZodObject<{
+                                    json: z.ZodString;
+                                    truncated: z.ZodBoolean;
+                                }, z.core.$strict>>;
                             }, z.core.$strict>]>;
                             state: z.ZodObject<{
                                 status: z.ZodEnum<{
@@ -1424,6 +1561,10 @@ export declare const fleetResultSchemas: {
                             }, z.core.$strict>, z.ZodObject<{
                                 kind: z.ZodLiteral<"other">;
                                 display: z.ZodString;
+                                input: z.ZodOptional<z.ZodObject<{
+                                    json: z.ZodString;
+                                    truncated: z.ZodBoolean;
+                                }, z.core.$strict>>;
                             }, z.core.$strict>]>;
                             state: z.ZodObject<{
                                 status: z.ZodEnum<{
@@ -1576,6 +1717,106 @@ export declare const fleetResultSchemas: {
             }>>]>;
         }, z.core.$strict>;
     }, z.core.$strict>;
+    tellWait: z.ZodObject<{
+        akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+        tell: z.ZodObject<{
+            admission: z.ZodObject<{
+                fact: z.ZodLiteral<"recorded">;
+                tellId: z.ZodString;
+            }, z.core.$strict>;
+            row: z.ZodObject<{
+                kind: z.ZodLiteral<"tell">;
+                sequence: z.ZodNumber;
+                at: z.ZodString;
+                tellId: z.ZodString;
+                text: z.ZodString;
+                state: z.ZodEnum<{
+                    pending: "pending";
+                    told: "told";
+                }>;
+                deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                    deliveredAt: z.ZodString;
+                    route: z.ZodEnum<{
+                        live: "live";
+                        launch: "launch";
+                    }>;
+                    turnSequence: z.ZodNumber;
+                    receipt: z.ZodOptional<z.ZodEnum<{
+                        required: "required";
+                        unavailable: "unavailable";
+                    }>>;
+                }, z.core.$strict>, z.ZodTransform<Readonly<{
+                    turnSequence: number;
+                    route: "launch" | "live";
+                    receipt?: "unavailable" | "required";
+                    deliveredAt: string;
+                }>, {
+                    deliveredAt: string;
+                    route: "live" | "launch";
+                    turnSequence: number;
+                    receipt?: "required" | "unavailable" | undefined;
+                }>>>>;
+            }, z.core.$strict>;
+            wake: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"told">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"held">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"pursuing">;
+                bodySequence: z.ZodNumber;
+            }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+                kind: z.ZodLiteral<"failed">;
+                diagnostic: z.ZodString;
+                child: z.ZodOptional<z.ZodObject<{
+                    code: z.ZodNullable<z.ZodNumber>;
+                    signal: z.ZodNullable<z.ZodString>;
+                    log: z.ZodObject<{
+                        path: z.ZodString;
+                        from: z.ZodNumber;
+                        to: z.ZodNumber;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodTransform<{
+                kind: "failed";
+                diagnostic: string;
+            } | {
+                child: {
+                    code: number | null;
+                    signal: string | null;
+                    log: {
+                        path: string;
+                        from: number;
+                        to: number;
+                    };
+                };
+                kind: "failed";
+                diagnostic: string;
+            }, {
+                kind: "failed";
+                diagnostic: string;
+                child?: {
+                    code: number | null;
+                    signal: string | null;
+                    log: {
+                        path: string;
+                        from: number;
+                        to: number;
+                    };
+                } | undefined;
+            }>>]>;
+        }, z.core.$strict>;
+        observation: z.ZodUnion<readonly [z.ZodObject<{
+            reason: z.ZodLiteral<"answered">;
+            answer: z.ZodUnknown;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"failed">;
+            diagnostic: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"unanswered">;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"deadline">;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>;
     kill: z.ZodObject<{
         results: z.ZodArray<z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;

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

@@ -58,6 +58,15 @@ const akumaWaitResultSchema = z
     .strict();
 const akumaKillResultSchema = z.object({ results: z.array(akumaKillResultItemSchema) }).strict();
 const akumaTellResultSchema = z.object({ akuma: akumaIdSchema, tell: tellResultSchema }).strict();
+const tellWaitObservationSchema = z.union([
+    z.object({ reason: z.literal("answered"), answer: z.unknown() }).strict(),
+    z.object({ reason: z.literal("failed"), diagnostic: z.string() }).strict(),
+    z.object({ reason: z.literal("unanswered") }).strict(),
+    z.object({ reason: z.literal("deadline") }).strict(),
+]);
+const akumaTellWaitResultSchema = z
+    .object({ akuma: akumaIdSchema, tell: tellResultSchema, observation: tellWaitObservationSchema })
+    .strict();
 export function parseAkumaObservation(value) {
     return akumaObservationSchema.parse(value);
 }
@@ -70,9 +79,13 @@ export function isKillResult(value) {
 export function isTellResult(value) {
     return akumaTellResultSchema.safeParse(value).success;
 }
+export function isTellWaitResult(value) {
+    return akumaTellWaitResultSchema.safeParse(value).success;
+}
 export const fleetResultSchemas = {
     wait: akumaWaitResultSchema,
     tell: akumaTellResultSchema,
+    tellWait: akumaTellWaitResultSchema,
     kill: akumaKillResultSchema,
     killEvidence: killEvidenceSchema,
 };

package/build/src/akuma/fleet-owner-port.d.ts

@@ -0,0 +1,12 @@
+import type { FleetRequestPort } from "./fleet-request.js";
+import type { WorldRoot } from "../world.js";
+/**
+ * The parent's Fleet owner boundary: one forwarded request arrives as complete
+ * identities the child resolved without reading a Heart, and this side answers
+ * for them. It proves every target through the one addressability
+ * normalization before the operation begins, so a refusal that reaches the wire
+ * truthfully claims no product effect and a plural operation with an
+ * unaddressable member never starts; the executor's own access to the target is
+ * then the product act, never a second addressing probe.
+ */
+export declare function fleetRequestPort(world: WorldRoot): FleetRequestPort;

package/build/src/akuma/fleet-owner-port.js

@@ -0,0 +1,46 @@
+import { requireBornAkuma } from "./akuma-probe.js";
+import { Akuma as PublicAkuma } from "./akuma-instance.js";
+import { executeKillAkuma, executeTellAkuma, executeTellWaitAkuma, executeWaitAkuma } from "./fleet-execution.js";
+import { Schema } from "./schema.js";
+/**
+ * The parent's Fleet owner boundary: one forwarded request arrives as complete
+ * identities the child resolved without reading a Heart, and this side answers
+ * for them. It proves every target through the one addressability
+ * normalization before the operation begins, so a refusal that reaches the wire
+ * truthfully claims no product effect and a plural operation with an
+ * unaddressable member never starts; the executor's own access to the target is
+ * then the product act, never a second addressing probe.
+ */
+export function fleetRequestPort(world) {
+    const prove = async (targets) => {
+        for (const id of targets)
+            await requireBornAkuma(world, id);
+    };
+    return {
+        wait: async ({ targets, ...request }) => {
+            await prove(targets);
+            return await executeWaitAkuma({ path: world, ids: targets, ...request });
+        },
+        tell: async ({ target, ...request }) => {
+            await prove([target]);
+            return await executeTellAkuma({ path: world, id: target, ...request });
+        },
+        tellWait: async ({ target, ...request }) => {
+            await prove([target]);
+            return await executeTellWaitAkuma({ path: world, id: target, ...request });
+        },
+        tellAnswer: async ({ target, ...request }) => {
+            await prove([target]);
+            return await PublicAkuma.select(world, target).tell(request.body, {
+                schema: Schema.json(JSON.parse(request.schemaJson), (value) => value),
+                ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
+                ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
+                signal: request.signal,
+            });
+        },
+        kill: async ({ targets, ...request }) => {
+            await prove(targets);
+            return await executeKillAkuma({ path: world, ids: targets, ...request });
+        },
+    };
+}

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

@@ -1,7 +1,7 @@
 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 { type AkumaKillResult, type AkumaTellResult, type AkumaTellWaitResult, type AkumaWaitResult } from "./fleet-observation.js";
 import { z } from "zod";
 import type { Schema } from "./schema.js";
 declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
@@ -55,6 +55,29 @@ declare const tellAnswerRequestSchema: z.ZodPipe<z.ZodObject<{
     initiator?: string | undefined;
     interrupt?: boolean | undefined;
 }>>;
+declare const tellWaitRequestSchema: z.ZodPipe<z.ZodObject<{
+    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+    body: z.ZodString;
+    timeoutMs: z.ZodNumber;
+    schemaJson: z.ZodOptional<z.ZodString>;
+    initiator: z.ZodOptional<z.ZodString>;
+    interrupt: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodTransform<{
+    target: import("./identity.js").AkuId;
+    body: string;
+    timeoutMs: number;
+    schemaJson?: string | undefined;
+    initiator?: string | undefined;
+    interrupt?: boolean | undefined;
+    action: "akuma.tell-wait";
+}, {
+    target: import("./identity.js").AkuId;
+    body: string;
+    timeoutMs: number;
+    schemaJson?: string | undefined;
+    initiator?: string | undefined;
+    interrupt?: boolean | undefined;
+}>>;
 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<{
@@ -71,6 +94,11 @@ declare const tellServiceSchema: z.ZodObject<{
     target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     tellId: z.ZodString;
 }, z.core.$strict>;
+declare const tellWaitServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.tell-wait">;
+    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<{
@@ -85,12 +113,14 @@ declare const killServiceSchema: z.ZodObject<{
         }>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare function encodeFleetLiveFailure(error: unknown): unknown | null;
+export declare function decodeFleetLiveFailure(value: unknown): Error | null;
 export type FleetRequest = (Omit<z.infer<typeof waitRequestSchema>, "targets"> & Readonly<{
     targets: readonly AkumaStatus["id"][];
-}>) | z.infer<typeof tellRequestSchema> | z.infer<typeof tellAnswerRequestSchema> | (Omit<z.infer<typeof killRequestSchema>, "targets"> & Readonly<{
+}>) | z.infer<typeof tellRequestSchema> | z.infer<typeof tellAnswerRequestSchema> | z.infer<typeof tellWaitRequestSchema> | (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<{
+export type FleetService = z.infer<typeof waitServiceSchema> | z.infer<typeof tellServiceSchema> | z.infer<typeof tellWaitServiceSchema> | (Omit<z.infer<typeof killServiceSchema>, "results"> & Readonly<{
     results: readonly Readonly<{
         id: AkumaStatus["id"];
         evidence: KillEvidence;
@@ -119,6 +149,17 @@ export type FleetRequestPort = Readonly<{
         interrupt?: boolean;
         signal: AbortSignal;
     }>): Promise<unknown>;
+    tellWait?(input: Readonly<{
+        target: AkumaStatus["id"];
+        body: string;
+        tellId: string;
+        recordedAt: string;
+        timeoutMs: number;
+        schemaJson?: string;
+        initiator?: string;
+        interrupt?: boolean;
+        signal: AbortSignal;
+    }>): Promise<AkumaTellWaitResult>;
     kill(input: Readonly<{
         targets: readonly AkumaStatus["id"][];
         signal: AbortSignal;
@@ -133,7 +174,7 @@ export type FleetRequestPort = Readonly<{
 /** 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.tell-answer" | "akuma.kill", ErasedRequestCommand>>;
+export declare function fleetRequestCommands(port: FleetRequestPort): Readonly<Record<"akuma.wait" | "akuma.tell" | "akuma.tell-answer" | "akuma.tell-wait" | "akuma.kill", ErasedRequestCommand>>;
 export declare function requestForwardedFleetTellAnswer(input: Readonly<{
     directory: string;
     target: AkumaStatus["id"];
@@ -157,6 +198,16 @@ export declare function requestForwardedFleetTell(input: Readonly<{
     initiator?: string;
     signal?: AbortSignal;
 }>): Promise<AkumaTellResult>;
+export declare function requestForwardedFleetTellWait(input: Readonly<{
+    directory: string;
+    target: AkumaStatus["id"];
+    body: string;
+    timeoutMs: number;
+    schema?: Schema<unknown>;
+    initiator?: string;
+    interrupt?: boolean;
+    signal?: AbortSignal;
+}>): Promise<AkumaTellWaitResult>;
 export declare function requestForwardedFleetKill(input: Readonly<{
     directory: string;
     targets: readonly AkumaStatus["id"][];