@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/{fleet-request.js → selection-request.js}

@@ -1,21 +1,22 @@
-import { akumaIdSchema } from "./akuma.js";
+import { z } from "zod";
+import { AkumaNotBornError, AkumaObservationError } from "./akuma-errors.js";
+import { akumaIdSchema } from "./identity.js";
 import { requestBodyCommand } from "./request-rendezvous.js";
 import { eraseRequestCommand, } from "./request-wire.js";
-import { fleetResultSchemas, isKillResult, isTellResult, isTellWaitResult, isWaitResult, } from "./fleet-observation.js";
-import { z } from "zod";
 import { schemaJsonText } from "./schema.js";
-import { AkumaDecodeError, AkumaNotBornError, AkumaObservationError } from "./akuma-errors.js";
+import { selectionResultSchemas, } from "./selection-observation.js";
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
-const fleetTargetsSchema = z
+const selectionTargetsSchema = z
     .array(akumaIdSchema)
     .min(1)
     .superRefine((ids, context) => {
     if (new Set(ids).size !== ids.length)
         context.addIssue({ code: "custom", message: "expected a deduplicated target set" });
-});
+})
+    .readonly();
 const waitRequestSchema = z
     .object({
-    targets: fleetTargetsSchema,
+    targets: selectionTargetsSchema,
     completion: z.enum(["any", "all"]),
     timeoutMs: z.number().int().nonnegative().optional(),
 })
@@ -26,65 +27,62 @@ const waitRequestSchema = z
     ...(timeoutMs === undefined ? {} : { timeoutMs }),
 }));
 const tellRequestSchema = z
-    .object({ target: akumaIdSchema, body: z.string(), initiator: nonblankTextSchema.optional() })
-    .strict()
-    .transform((request) => ({ action: "akuma.tell", ...request }));
-const tellAnswerRequestSchema = z
     .object({
     target: akumaIdSchema,
     body: z.string(),
-    schemaJson: nonblankTextSchema,
     initiator: nonblankTextSchema.optional(),
     interrupt: z.boolean().optional(),
 })
     .strict()
-    .transform((request) => ({ action: "akuma.tell-answer", ...request }));
-const tellWaitRequestSchema = z
+    .transform((request) => ({ action: "akuma.tell", ...request }));
+const askRequestSchema = z
     .object({
     target: akumaIdSchema,
     body: z.string(),
-    timeoutMs: z.number().int().nonnegative(),
+    timeoutMs: z.number().int().nonnegative().optional(),
     schemaJson: nonblankTextSchema.optional(),
     initiator: nonblankTextSchema.optional(),
     interrupt: z.boolean().optional(),
 })
     .strict()
-    .transform((request) => ({ action: "akuma.tell-wait", ...request }));
+    .transform((request) => ({ action: "akuma.ask", ...request }));
 const killRequestSchema = z
-    .object({ targets: fleetTargetsSchema })
+    .object({ targets: selectionTargetsSchema })
     .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 tellWaitServiceSchema = z
-    .object({ action: z.literal("akuma.tell-wait"), target: akumaIdSchema, tellId: nonblankTextSchema })
+const askServiceSchema = z
+    .object({ action: z.literal("akuma.ask"), 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()),
+    results: z
+        .array(z.object({ id: akumaIdSchema, evidence: selectionResultSchemas.killEvidence }).strict())
+        .readonly(),
 })
     .strict();
 /**
- * A forwarded Fleet request leaves selection and observation to the parent, so
+ * A forwarded Selection request leaves selection and observation to the parent, so
  * the parent's typed refusal is the only evidence the child can classify on.
  * Transporting it is the codec's own duty: an unencoded failure reaches the
  * caller as an anonymous request error and loses the identity it names.
  *
  * The transport voids a begun request only when the encoded failure proves no
  * product effect. A refused selection or an unreadable observation never
- * reached an action, so Fleet proves that through the same refusal envelope
+ * reached an action, so Selection proves that through the same refusal envelope
  * the Contract codec uses; a genuinely failed action stays unencoded and
  * keeps its existing anonymous classification.
  */
-const fleetRefusalSchema = z.union([
+const selectionRefusalSchema = z.union([
     z.object({ kind: z.literal("akuma-not-born"), id: akumaIdSchema }).strict(),
     z.object({ kind: z.literal("akuma-observation"), id: akumaIdSchema, diagnostic: z.string() }).strict(),
 ]);
-const fleetLiveFailureSchema = z.object({ kind: z.literal("refused"), failure: fleetRefusalSchema }).strict();
-export function encodeFleetLiveFailure(error) {
+const selectionLiveFailureSchema = z.object({ kind: z.literal("refused"), failure: selectionRefusalSchema }).strict();
+export function encodeSelectionLiveFailure(error) {
     const failure = error instanceof AkumaNotBornError
         ? { kind: "akuma-not-born", id: error.id }
         : error instanceof AkumaObservationError
@@ -92,8 +90,8 @@ export function encodeFleetLiveFailure(error) {
             : null;
     return failure === null ? null : { kind: "refused", failure };
 }
-export function decodeFleetLiveFailure(value) {
-    const parsed = fleetLiveFailureSchema.safeParse(value);
+export function decodeSelectionLiveFailure(value) {
+    const parsed = selectionLiveFailureSchema.safeParse(value);
     if (!parsed.success)
         return null;
     const failure = parsed.data.failure;
@@ -101,49 +99,45 @@ export function decodeFleetLiveFailure(value) {
         ? new AkumaNotBornError(failure.id)
         : new AkumaObservationError(failure.id, failure.diagnostic);
 }
-function decodeFleetRequest(action, value) {
+function decodeSelectionRequest(action, value) {
     const schema = action === "akuma.wait"
         ? waitRequestSchema
         : action === "akuma.tell"
             ? tellRequestSchema
-            : action === "akuma.tell-answer"
-                ? tellAnswerRequestSchema
-                : action === "akuma.tell-wait"
-                    ? tellWaitRequestSchema
-                    : killRequestSchema;
+            : action === "akuma.ask"
+                ? askRequestSchema
+                : killRequestSchema;
     const parsed = schema.safeParse(value);
     return parsed.success ? parsed.data : null;
 }
-function decodeFleetService(action, value) {
+function decodeSelectionService(action, value) {
     const schema = action === "akuma.wait"
         ? waitServiceSchema
-        : action === "akuma.tell" || action === "akuma.tell-answer"
+        : action === "akuma.tell"
             ? tellServiceSchema
-            : action === "akuma.tell-wait"
-                ? tellWaitServiceSchema
+            : action === "akuma.ask"
+                ? askServiceSchema
                 : killServiceSchema;
     const parsed = schema.safeParse(value);
     if (!parsed.success)
-        throw new Error("malformed stored Fleet service evidence");
+        throw new Error("malformed stored Selection service evidence");
     return parsed.data;
 }
-function decodedFleetResult(action, value) {
-    if (action === "akuma.tell-answer")
-        return value;
+function decodedSelectionResult(action, value) {
     const schema = action === "akuma.wait"
-        ? fleetResultSchemas.wait
+        ? selectionResultSchemas.wait
         : action === "akuma.tell"
-            ? fleetResultSchemas.tell
-            : action === "akuma.tell-wait"
-                ? fleetResultSchemas.tellWait
-                : fleetResultSchemas.kill;
+            ? selectionResultSchemas.tell
+            : action === "akuma.ask"
+                ? selectionResultSchemas.ask
+                : selectionResultSchemas.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) {
+export function selectionRequestProtocol(action) {
     return {
         action,
         supportsCancellation: true,
@@ -151,70 +145,58 @@ export function fleetRequestProtocol(action) {
             const { action: _action, ...payload } = request;
             return payload;
         },
-        decodeRequest: (payload) => decodeFleetRequest(action, payload),
+        decodeRequest: (payload) => decodeSelectionRequest(action, payload),
         encodeResult: (result) => result,
-        decodeResult: (result) => decodedFleetResult(action, result),
-        encodeFailure: encodeFleetLiveFailure,
-        decodeFailure: decodeFleetLiveFailure,
-        decodeReference: (reference) => decodeFleetService(action, reference),
+        decodeResult: (result) => decodedSelectionResult(action, result),
+        encodeFailure: encodeSelectionLiveFailure,
+        decodeFailure: decodeSelectionLiveFailure,
+        decodeReference: (reference) => decodeSelectionService(action, reference),
         isPermitted: (allowed) => action === "akuma.wait" ||
-            ((action === "akuma.tell" || action === "akuma.tell-answer" || action === "akuma.tell-wait") &&
-                allowed.includes("akuma.tell")) ||
+            ((action === "akuma.tell" || action === "akuma.ask") && allowed.includes("akuma.tell")) ||
             (action === "akuma.kill" && allowed.includes("akuma.kill")),
     };
 }
-export function fleetRequestCommand(action, port) {
+export function selectionRequestCommand(action, port) {
     return {
         completion: "service",
-        protocol: fleetRequestProtocol(action),
-        encodeService: (service) => decodeFleetService(action, service),
-        decodeService: (service) => decodeFleetService(action, service),
-        projectService: (service) => decodeFleetService(action, service),
+        protocol: selectionRequestProtocol(action),
+        encodeService: (service) => service,
+        decodeService: (service) => decodeSelectionService(action, service),
+        projectService: (service) => service,
         execute: async (request, facts) => {
             if (request.action === "akuma.wait") {
                 return {
+                    kind: "served",
                     result: await port.wait({ ...request, signal: facts.signal }),
                     service: { action: request.action },
                 };
             }
             if (request.action === "akuma.tell") {
                 return {
+                    kind: "served",
                     result: await port.tell({
                         target: request.target,
                         body: request.body,
                         tellId: facts.id,
                         ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
+                        ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
                         recordedAt: facts.admittedAt,
                         signal: facts.signal,
                     }),
                     service: { action: request.action, target: request.target, tellId: facts.id },
                 };
             }
-            if (request.action === "akuma.tell-answer") {
-                if (port.tellAnswer === undefined)
-                    throw new Error("schema answer Fleet port is unavailable");
-                return {
-                    result: await port.tellAnswer({
-                        target: request.target,
-                        body: request.body,
-                        schemaJson: request.schemaJson,
-                        ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
-                        ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
-                        signal: facts.signal,
-                    }),
-                    service: { action: "akuma.tell", target: request.target, tellId: facts.id },
-                };
-            }
-            if (request.action === "akuma.tell-wait") {
-                if (port.tellWait === undefined)
-                    throw new Error("bounded Tell Fleet port is unavailable");
+            if (request.action === "akuma.ask") {
+                if (port.ask === undefined)
+                    throw new Error("bounded Tell Selection port is unavailable");
                 return {
-                    result: await port.tellWait({
+                    kind: "served",
+                    result: await port.ask({
                         target: request.target,
                         body: request.body,
                         tellId: facts.id,
                         recordedAt: facts.admittedAt,
-                        timeoutMs: request.timeoutMs,
+                        ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
                         ...(request.schemaJson === undefined ? {} : { schemaJson: request.schemaJson }),
                         ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
                         ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
@@ -225,64 +207,37 @@ export function fleetRequestCommand(action, port) {
             }
             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 { kind: "served", result: result.result, service: { action: request.action, results: result.service } };
             return {
+                kind: "served",
                 result,
                 service: { action: request.action, results: result.results.map(({ id, evidence }) => ({ id, evidence })) },
             };
         },
     };
 }
-export function fleetRequestCommands(port) {
+export function selectionRequestCommands(port) {
     return {
-        "akuma.wait": eraseRequestCommand(fleetRequestCommand("akuma.wait", port)),
-        "akuma.tell": eraseRequestCommand(fleetRequestCommand("akuma.tell", port)),
-        "akuma.tell-answer": eraseRequestCommand(fleetRequestCommand("akuma.tell-answer", port)),
-        "akuma.tell-wait": eraseRequestCommand(fleetRequestCommand("akuma.tell-wait", port)),
-        "akuma.kill": eraseRequestCommand(fleetRequestCommand("akuma.kill", port)),
+        "akuma.wait": eraseRequestCommand(selectionRequestCommand("akuma.wait", port)),
+        "akuma.tell": eraseRequestCommand(selectionRequestCommand("akuma.tell", port)),
+        "akuma.ask": eraseRequestCommand(selectionRequestCommand("akuma.ask", port)),
+        "akuma.kill": eraseRequestCommand(selectionRequestCommand("akuma.kill", port)),
     };
 }
-export async function requestForwardedFleetTellAnswer(input) {
-    const response = await requestBodyCommand({
-        directory: input.directory,
-        command: fleetRequestProtocol("akuma.tell-answer"),
-        value: {
-            action: "akuma.tell-answer",
-            target: input.target,
-            body: input.body,
-            schemaJson: schemaJsonText(input.schema),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
-        },
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-    if (response.kind !== "returned")
-        throw new Error("Akuma body request terminal schema answer cannot reproduce an expired live result");
-    try {
-        return input.schema.decode(response.result);
-    }
-    catch (error) {
-        throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer failed schema decode", typeof response.result === "string" ? response.result : JSON.stringify(response.result));
-    }
-}
-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.tell-wait" && isTellWaitResult(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");
+/**
+ * The one terminal guard for every forwarded Selection operation: a returned
+ * live result is the operation's own answer, and a durable reference can never
+ * reproduce an expired live result.
+ */
+function forwardedSelectionResult(response) {
+    if (response.kind === "returned")
+        return response.result;
+    throw new Error("Akuma body request terminal Selection reference cannot reproduce an expired live result");
 }
-export async function requestForwardedFleetWait(input) {
+export async function requestForwardedSelectionWait(input) {
     const response = await requestBodyCommand({
         directory: input.directory,
-        command: fleetRequestProtocol("akuma.wait"),
+        command: selectionRequestProtocol("akuma.wait"),
         value: {
             action: "akuma.wait",
             targets: input.targets,
@@ -291,45 +246,46 @@ export async function requestForwardedFleetWait(input) {
         },
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
-    return forwardedFleetCommandResult(response, "akuma.wait");
+    return forwardedSelectionResult(response);
 }
-export async function requestForwardedFleetTell(input) {
+export async function requestForwardedSelectionTell(input) {
     const response = await requestBodyCommand({
         directory: input.directory,
-        command: fleetRequestProtocol("akuma.tell"),
+        command: selectionRequestProtocol("akuma.tell"),
         value: {
             action: "akuma.tell",
             target: input.target,
             body: input.body,
             ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(input.interrupt === true ? { interrupt: true } : {}),
         },
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
-    return forwardedFleetCommandResult(response, "akuma.tell");
+    return forwardedSelectionResult(response);
 }
-export async function requestForwardedFleetTellWait(input) {
+export async function requestForwardedSelectionAsk(input) {
     const response = await requestBodyCommand({
         directory: input.directory,
-        command: fleetRequestProtocol("akuma.tell-wait"),
+        command: selectionRequestProtocol("akuma.ask"),
         value: {
-            action: "akuma.tell-wait",
+            action: "akuma.ask",
             target: input.target,
             body: input.body,
-            timeoutMs: input.timeoutMs,
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
             ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
             ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
             ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
         },
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
-    return forwardedFleetCommandResult(response, "akuma.tell-wait");
+    return forwardedSelectionResult(response);
 }
-export async function requestForwardedFleetKill(input) {
+export async function requestForwardedSelectionKill(input) {
     const response = await requestBodyCommand({
         directory: input.directory,
-        command: fleetRequestProtocol("akuma.kill"),
+        command: selectionRequestProtocol("akuma.kill"),
         value: { action: "akuma.kill", targets: input.targets },
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
-    return forwardedFleetCommandResult(response, "akuma.kill");
+    return forwardedSelectionResult(response);
 }

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

@@ -288,6 +288,63 @@ async function settleCompletion(result, session, active) {
         active.releaseDriveSignal();
     }
 }
+/**
+ * One bounded wake slot per live Turn source.
+ *
+ * A stalled provider leaves its current event pull pending, so attaching a fresh reaction to that
+ * pull on every control observation retains a reaction and a derived promise per tick. Here each
+ * source registers exactly one reaction and is re-armed only after the wake it produced has been
+ * consumed; terminal sources settle once and are never re-armed. The queue therefore holds at most
+ * one wake per source. A new Heart observation is armed only after the prior observation is
+ * consumed, so the wait never falls back to an older snapshot. Stop clears the queue and its
+ * waiter; later notifications are ignored rather than written, though the one reaction already
+ * registered on a source that never settled stays attached until that source settles.
+ */
+function createTurnWakeups(observeHeart) {
+    const queue = [];
+    let waiter;
+    let stopped = false;
+    const publish = (wakeup) => {
+        if (stopped)
+            return;
+        const waiting = waiter;
+        waiter = undefined;
+        if (waiting === undefined)
+            queue.push(wakeup);
+        else
+            waiting(wakeup);
+    };
+    return {
+        event: (pull) => {
+            void pull.then((event) => publish({ kind: "event", event }), (error) => publish({ kind: "failed", error }));
+        },
+        heart: (after) => {
+            void observeHeart(after).then((observation) => publish({ kind: "heart", observation }), (error) => publish({ kind: "failed", error }));
+        },
+        tell: (submission) => {
+            void submission.then((result) => publish({ kind: "tell", result }), (error) => publish({ kind: "failed", error }));
+        },
+        failure: (source) => {
+            void source.then(() => undefined, (error) => publish({ kind: "failed", error }));
+        },
+        completionFailed: (source) => {
+            void source.then((wakeup) => publish(wakeup));
+        },
+        next: () => {
+            const ready = queue.shift();
+            if (ready !== undefined)
+                return Promise.resolve(ready);
+            return new Promise((resolve) => {
+                waiter = resolve;
+            });
+        },
+        stop: () => {
+            stopped = true;
+            waiter = undefined;
+            queue.length = 0;
+        },
+    };
+}
 async function consumeTurnDrive(input, active) {
     const { turnSequence, drive, requests, resume } = active;
     let heart = input.supervisor.current();
@@ -300,10 +357,15 @@ async function consumeTurnDrive(input, active) {
     const receiptFailure = observeReceiptFailure(pumpReceipts(writers));
     const completionFailure = observeCompletionFailure(drive);
     const iterator = drive.events[Symbol.asyncIterator]();
-    let pending = iterator.next();
     let liveTells = true;
     let tellPump = null;
-    let tellObservation = null;
+    const wakeups = createTurnWakeups((after) => input.supervisor.next(after));
+    wakeups.event(iterator.next());
+    wakeups.heart(heart);
+    wakeups.failure(receiptFailure);
+    wakeups.failure(requests.failure);
+    wakeups.failure(active.custodyFailure);
+    wakeups.completionFailed(completionFailure);
     try {
         for (;;) {
             if (input.supervisor.signal.aborted) {
@@ -318,28 +380,22 @@ async function consumeTurnDrive(input, active) {
                     return retirement.kind === "hung" ? retirement : { kind: "handoff" };
                 }
                 tellPump = submitPendingLiveTells(writers, heart.pending, attempted, drive.tell);
-                tellObservation = tellPump.then((result) => ({ kind: "tell", result }));
+                wakeups.tell(tellPump);
             }
-            const next = await Promise.race([
-                pending.then((event) => ({ kind: "event", event })),
-                input.supervisor.next(heart).then((observation) => ({ kind: "heart", observation })),
-                ...(tellObservation === null ? [] : [tellObservation]),
-                receiptFailure,
-                requests.failure,
-                completionFailure,
-                active.custodyFailure,
-            ]);
+            const next = await wakeups.next();
             if (next.kind === "completion-failed") {
                 requests.stopAdmission();
                 throw next.error;
             }
+            if (next.kind === "failed")
+                throw next.error;
             if (next.kind === "heart") {
                 heart = next.observation;
+                wakeups.heart(heart);
                 continue;
             }
             if (next.kind === "tell") {
                 tellPump = null;
-                tellObservation = null;
                 liveTells = next.result === "live";
                 continue;
             }
@@ -348,7 +404,7 @@ async function consumeTurnDrive(input, active) {
             await writeProviderEvent(input, active, next.event.value);
             if (next.event.value.type === "session")
                 turnSession = next.event.value.coordinate;
-            pending = iterator.next();
+            wakeups.event(iterator.next());
         }
         const result = await drive.completion;
         await active.attempt.closed;
@@ -376,6 +432,9 @@ async function consumeTurnDrive(input, active) {
             return retirement;
         return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
     }
+    finally {
+        wakeups.stop();
+    }
 }
 export async function driveTurn(input) {
     let active;