@astrosheep/keiyaku 4.5.24 → 4.5.25

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

@@ -2,6 +2,7 @@ import { type TellResult, type TellWakeRuntime } from "./body.js";
 import { HeldAkumaLeash, type KillEvidence } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
 import { type ActivityHistory, type ExactHistory } from "./projection.js";
+import { type WaitReason } from "./akuma-observe.js";
 import type { AkumaCallExecution, AkumaStatus, ForkReceipt, InterruptReceipt } from "./akuma.js";
 import type { WorldRoot } from "../world.js";
 declare const CALL_EXECUTION: unique symbol;
@@ -25,12 +26,21 @@ export declare class AkumaHandle {
         since?: number;
         limit?: number;
     }>): Promise<ActivityHistory | ExactHistory>;
+    waitReceipt(predicate?: (status: AkumaStatus) => boolean, options?: Readonly<{
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }>): Promise<Readonly<{
+        reason: WaitReason;
+        status: AkumaStatus;
+    }>>;
     wait(predicate?: (status: AkumaStatus) => boolean, options?: Readonly<{
         timeoutMs?: number;
+        signal?: AbortSignal;
     }>): Promise<AkumaStatus>;
     tell(body: string, tellId?: string, recordedAt?: string, runtime?: TellWakeRuntime, options?: Readonly<{
         schemaJson?: string;
         initiator?: string;
+        signal?: AbortSignal;
     }>): Promise<TellResult>;
     interrupt(body: string, options?: Readonly<{
         tellId?: string;

package/build/src/akuma/akuma-handle.js

@@ -8,10 +8,8 @@ import { resolveProviderExecution } from "./providers/index.js";
 import { publishAkuma } from "./publication.js";
 import { spawnAkumaBody } from "./body.js";
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { bornStatus, defaultWaitComplete, readWaitComplete } from "./akuma-observe.js";
+import { bornStatus, defaultWaitComplete, readWaitComplete, waitForObservation, } from "./akuma-observe.js";
 const CALL_EXECUTION = Symbol("akuma-call-execution");
-const POLL_MS = 100;
-const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -134,24 +132,26 @@ export class AkumaHandle {
             limit,
         });
     }
-    async wait(predicate = defaultWaitComplete, options = {}) {
+    async waitReceipt(predicate = defaultWaitComplete, options = {}) {
         if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
             throw new TypeError("Akuma wait timeoutMs must be a nonnegative finite millisecond duration");
         }
-        const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
-        for (;;) {
-            if (predicate !== defaultWaitComplete ||
-                (deadline !== undefined && performance.now() >= deadline) ||
-                (await readWaitComplete(this.worldPath, this.id))) {
-                const status = await this.status();
-                if (predicate(status) || (deadline !== undefined && performance.now() >= deadline))
-                    return status;
-            }
-            await wait(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
-        }
+        const waited = await waitForObservation({
+            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(predicate === defaultWaitComplete
+                ? { probe: async () => await readWaitComplete(this.worldPath, this.id) }
+                : {}),
+            observe: async () => await this.status(),
+            complete: predicate,
+        });
+        return { reason: waited.reason, status: waited.value };
+    }
+    async wait(predicate = defaultWaitComplete, options = {}) {
+        return (await this.waitReceipt(predicate, options)).status;
     }
     async tell(body, tellId = randomUUID(), recordedAt = new Date().toISOString(), runtime, options = {}) {
-        const { schemaJson, initiator } = options;
+        const { schemaJson, initiator, signal } = options;
         const admitted = await recordTell(this.paths, {
             kind: "tell",
             id: tellId,
@@ -162,7 +162,7 @@ export class AkumaHandle {
         });
         if (admitted.kind === "not-born")
             throw new AkumaNotBornError(this.id);
-        return await wakeRecordedTell(this.paths, admitted.tell.id, runtime);
+        return await wakeRecordedTell(this.paths, admitted.tell.id, runtime, signal);
     }
     async interrupt(body, options = {}) {
         const request = await requestPause(this.paths, new Date().toISOString(), options.signal);
@@ -212,7 +212,7 @@ export class AkumaHandle {
         return {
             kind: "interrupted",
             putDown,
-            tell: await wakeRecordedTell(this.paths, recorded.tellId, options.runtime),
+            tell: await wakeRecordedTell(this.paths, recorded.tellId, options.runtime, options.signal),
         };
     }
     async fork(input) {

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

@@ -1,6 +1,7 @@
 import type { AllowedAction } from "./allowed.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { InterruptReceipt, KillEvidence } from "./akuma.js";
+import { type WaitReason } from "./akuma-observe.js";
 import { type AkuId } from "./identity.js";
 import { type ActivityHistory } from "./projection.js";
 import type { Settings } from "../settings.js";
@@ -8,18 +9,11 @@ import type { WorldRoot } from "../world.js";
 import { type Schema, type StandardSchemaV1 } from "./schema.js";
 export type AkumaIdleOptions = Readonly<{
     timeoutMs?: number;
+    signal?: AbortSignal;
 }>;
 export type AkumaIdleResult = Readonly<{
-    kind: "idle";
-    status: AkumaStatus;
-    reason: Exclude<AkumaStatus["life"], "running">;
-}> | Readonly<{
-    kind: "timeout";
+    reason: WaitReason;
     status: AkumaStatus;
-    reason: Readonly<{
-        running: boolean;
-        pendingTell: boolean;
-    }>;
 }>;
 export type AkumaHistoryOptions = Readonly<{
     before?: number;
@@ -51,8 +45,9 @@ export declare class Akuma {
     static select(root: WorldRoot, selector: string): Akuma;
     tell(text: string, options?: Readonly<{
         initiator?: string;
+        signal?: AbortSignal;
     }>): Promise<string>;
-    tell<T>(text: string, options: AkumaTellOptions<T>): Promise<T>;
+    tell<T>(text: string, options: AkumaTellOptions<T> & AkumaSignalOptions): Promise<T>;
     status(): Promise<AkumaStatus>;
     interrupt(text: string, options?: AkumaSignalOptions & Readonly<{
         initiator?: string;

package/build/src/akuma/akuma-instance.js

@@ -4,8 +4,7 @@ import { spawnAkumaBody } from "./body.js";
 import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
 import { AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";
 import { AkumaHandle } from "./akuma-handle.js";
-import { POLL_MS, defaultWaitComplete } from "./akuma.js";
-import { bornStatus } from "./akuma-observe.js";
+import { bornStatus, defaultWaitComplete, waitForObservation } from "./akuma-observe.js";
 import { loadArchetype } from "./archetype.js";
 import { activitySlice, readTell, readTurn } from "./heart/index.js";
 import { parseAkuId, pathsForAkuId } from "./identity.js";
@@ -22,27 +21,29 @@ function signalOption(value) {
         throw new TypeError("signal must be an AbortSignal");
     return value;
 }
-function wait(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-function pendingTellOf(status) {
-    return status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending");
-}
-function idleResult(status) {
-    const pendingTell = pendingTellOf(status);
-    if (status.life !== "running" && !pendingTell)
-        return { kind: "idle", status, reason: status.life };
-    return { kind: "timeout", status, reason: { running: status.life === "running", pendingTell } };
-}
 function recordedTell(result) {
     if (result.wake.kind === "failed")
         throw new AkumaProviderError(result.wake.diagnostic);
     return { tellId: result.admission.tellId };
 }
-async function recordPlainTell(id, root, body, tellId, initiator) {
-    const admitted = await new AkumaHandle(id, root).tell(body, tellId, undefined, undefined, initiator === undefined ? {} : { initiator });
+async function recordPlainTell(input) {
+    const { id, root, body, tellId, initiator, signal } = input;
+    const admitted = await new AkumaHandle(id, root).tell(body, tellId, undefined, undefined, {
+        ...(initiator === undefined ? {} : { initiator }),
+        ...(signal === undefined ? {} : { signal }),
+    });
     return recordedTell(admitted);
 }
+function plainTellInput(input) {
+    return {
+        id: input.id,
+        root: input.root,
+        body: input.body,
+        tellId: input.tellId,
+        ...(input.options?.initiator === undefined ? {} : { initiator: input.options.initiator }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    };
+}
 async function recordSchemaTell(input) {
     const { id, body, tellId, schema, root } = input;
     if (input.interrupt === true) {
@@ -50,6 +51,7 @@ async function recordSchemaTell(input) {
             tellId,
             schemaJson: schemaJsonText(schema),
             ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
         if (interrupted.kind === "unavailable") {
             throw new AkumaProviderError(`schema interrupt unavailable: ${interrupted.evidence}`);
@@ -59,6 +61,7 @@ async function recordSchemaTell(input) {
     const admitted = await new AkumaHandle(id, root).tell(body, tellId, undefined, undefined, {
         schemaJson: schemaJsonText(schema),
         ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
     return recordedTell(admitted);
 }
@@ -75,19 +78,21 @@ async function boundOutcome(paths, tell) {
     const turn = await readTurn(paths, tell.binding.turnSequence);
     return turn?.end?.outcome ?? null;
 }
-async function awaitTellOutcome(paths, tellId) {
-    for (;;) {
-        const tell = await readTell(paths, tellId);
-        if (tell === null)
-            throw new AkumaProviderError(`recorded Tell ${tellId} is missing from Heart`);
-        const outcome = await boundOutcome(paths, tell);
-        if (outcome !== null)
-            return outcome;
-        if (tell.state === "told" && tell.binding === undefined) {
-            throw new AkumaProviderError(`recorded Tell ${tellId} reached a terminal delivery without a Turn binding`);
-        }
-        await wait(POLL_MS);
-    }
+async function awaitTellOutcome(paths, tellId, signal) {
+    const waited = await waitForObservation({
+        ...(signal === undefined ? {} : { signal }),
+        observe: async () => {
+            const tell = await readTell(paths, tellId);
+            if (tell === null)
+                throw new AkumaProviderError(`recorded Tell ${tellId} is missing from Heart`);
+            const outcome = await boundOutcome(paths, tell);
+            return { outcome, terminalWithoutTurn: tell.state === "told" && tell.binding === undefined };
+        },
+        complete: (observed) => observed.outcome !== null || observed.terminalWithoutTurn,
+    });
+    if (waited.value.outcome !== null)
+        return waited.value.outcome;
+    throw new AkumaProviderError(`recorded Tell ${tellId} reached a terminal delivery without a Turn binding`);
 }
 export class Akuma {
     id;
@@ -143,11 +148,20 @@ export class Akuma {
     async tell(text, options) {
         if (typeof text !== "string")
             throw new TypeError("Akuma tell text must be a string");
+        const signal = signalOption(options?.signal);
+        signal?.throwIfAborted();
         const tellId = randomUUID();
         const schemaOptions = options !== undefined && "schema" in options ? options : undefined;
         const schema = schemaOptions === undefined ? undefined : schemaFromStandard(schemaOptions.schema);
         const recorded = schemaOptions === undefined || schema === undefined
-            ? await recordPlainTell(this.id, this.root, text, tellId, options?.initiator)
+            ? await recordPlainTell(plainTellInput({
+                id: this.id,
+                root: this.root,
+                body: text,
+                tellId,
+                options,
+                signal,
+            }))
             : await recordSchemaTell({
                 id: this.id,
                 body: text,
@@ -156,8 +170,9 @@ export class Akuma {
                 root: this.root,
                 ...(schemaOptions.interrupt === undefined ? {} : { interrupt: schemaOptions.interrupt }),
                 ...(schemaOptions.initiator === undefined ? {} : { initiator: schemaOptions.initiator }),
+                ...(signal === undefined ? {} : { signal }),
             });
-        const outcome = await awaitTellOutcome(this.paths, recorded.tellId);
+        const outcome = await awaitTellOutcome(this.paths, recorded.tellId, signal);
         if (outcome.kind !== "answered")
             outcomeError(outcome);
         if (schema === undefined)
@@ -198,20 +213,20 @@ export class Akuma {
         if (typeof options !== "object" || options === null || Array.isArray(options)) {
             throw new TypeError("Akuma idle options must be an object");
         }
-        const unknown = Object.keys(options).find((key) => key !== "timeoutMs");
+        const unknown = Object.keys(options).find((key) => key !== "timeoutMs" && key !== "signal");
         if (unknown !== undefined)
             throw new TypeError(`Akuma idle options has unknown field: ${unknown}`);
         if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
             throw new TypeError("Akuma idle timeoutMs must be a nonnegative finite millisecond duration");
         }
-        const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
-        for (;;) {
-            const observed = await bornStatus(this.paths, this.id, { aperture: "monitoring" });
-            if (defaultWaitComplete(observed.status) || (deadline !== undefined && performance.now() >= deadline)) {
-                return idleResult(observed.status);
-            }
-            await wait(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
-        }
+        const signal = signalOption(options.signal);
+        const waited = await waitForObservation({
+            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+            ...(signal === undefined ? {} : { signal }),
+            observe: async () => (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status,
+            complete: defaultWaitComplete,
+        });
+        return { reason: waited.reason, status: waited.value };
     }
     async history(options = {}) {
         if (typeof options !== "object" || options === null || Array.isArray(options)) {

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

@@ -1,5 +1,5 @@
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import { selectHistory, type ActivityHistory, type ActivitySnapshot } from "./projection.js";
+import { selectHistory, type ActivityHistory, type ActivityRow, type ActivitySnapshot } from "./projection.js";
 import type { WorldRoot } from "../world.js";
 import type { AkumaListRow, AkumaStatus, UnbornAkumaListRow } from "./akuma.js";
 export declare function fleetListRow(paths: AkumaPaths, expected: AkuId): Promise<AkumaListRow | UnbornAkumaListRow>;
@@ -7,6 +7,14 @@ export type BudgetedStatusObservation = Readonly<{
     status: AkumaStatus;
     ordinarySelected: number;
 }>;
+/**
+ * The internal live-observation companion for one status frontier.  It is not
+ * part of status or any returned facade result: viewers receive it only while
+ * an observation loop is still streaming.
+ */
+export type LiveStatusObservation = BudgetedStatusObservation & Readonly<{
+    rows: readonly ActivityRow[];
+}>;
 export declare function bornStatus(paths: AkumaPaths, expected: AkuId, input: Readonly<{
     aperture: "monitoring" | "receipt";
     ordinaryBudget?: number;
@@ -17,18 +25,43 @@ export declare function readBudgetedStatus(worldPath: WorldRoot, id: AkuId, inpu
     ordinaryBudget?: number;
     admittedTellId?: string;
 }>): Promise<BudgetedStatusObservation>;
+export declare function readLiveStatus(worldPath: WorldRoot, id: AkuId, input: Readonly<{
+    aperture: "monitoring" | "receipt";
+    ordinaryBudget?: number;
+    admittedTellId?: string;
+}>): Promise<LiveStatusObservation>;
 export declare function defaultWaitComplete(status: AkumaStatus): boolean;
 export declare function readWaitComplete(worldPath: WorldRoot, id: AkuId): Promise<boolean>;
+export type WaitReason = "completed" | "deadline";
+/**
+ * The one deadline-aware observation loop for public Akuma waiting.  It always
+ * reads once before judging a passed deadline, so a zero-duration wait remains
+ * an honest final snapshot and completion wins at the deadline edge.
+ */
+export declare function waitForObservation<T>(input: Readonly<{
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    probe?(): Promise<boolean>;
+    observe(): Promise<T>;
+    complete(value: T): boolean;
+    onObserve?(value: T): void | Promise<void>;
+}>): Promise<Readonly<{
+    reason: WaitReason;
+    value: T;
+}>>;
 /**
  * Successive status observations of one already born Akuma until its
- * observation window closes. Every status observed while the window is open is
- * reported to `observe`; the window's last status is returned. A window that is
- * already closed, or an Akuma already at its completion judgment, reports
- * nothing and returns the current status.
+ * observation window closes. Every acquired observation is reported to
+ * `observe` before completion or deadline judgment, including the first
+ * already-complete observation; the last status is returned.
  */
 export declare function observeAkumaStatus(worldPath: WorldRoot, expected: AkuId, input: Readonly<{
     timeoutMs: number;
-    observe: (status: AkumaStatus) => void;
-}>): Promise<AkumaStatus>;
+    signal?: AbortSignal;
+    observe: (status: LiveStatusObservation) => void;
+}>): Promise<Readonly<{
+    reason: WaitReason;
+    status: AkumaStatus;
+}>>;
 export declare function readAkumaBirthCwd(worldPath: WorldRoot, id: AkuId): Promise<string>;
 export { selectHistory, type ActivityHistory, type ActivitySnapshot };

package/build/src/akuma/akuma-observe.js

@@ -2,6 +2,7 @@ import { readStatusFacts, readLifeSnapshot, HeldAkumaLeash, isHeartAbsent, life,
 import { pathsForAkuId } from "./identity.js";
 import { ordinarySnapshotBudget, projectTurns, selectHistory, selectSnapshot, } from "./projection.js";
 import { resolveProviderExecution } from "./providers/index.js";
+import { abortableDelay } from "./abort.js";
 import { AkumaNotBornError } from "./akuma-errors.js";
 export async function fleetListRow(paths, expected) {
     const snapshot = await readHeart(paths);
@@ -55,7 +56,7 @@ async function bornObservation(paths, expected, read, snapshot) {
         claim?.release();
     }
 }
-export async function bornStatus(paths, expected, input) {
+async function bornLiveStatus(paths, expected, input) {
     if (input.ordinaryBudget !== undefined && (!Number.isSafeInteger(input.ordinaryBudget) || input.ordinaryBudget < 0))
         throw new TypeError("ordinary budget must be a nonnegative safe integer");
     const { snapshot, soul, currentLife } = await bornObservation(paths, expected, () => readLifeSnapshot(paths));
@@ -63,7 +64,8 @@ export async function bornStatus(paths, expected, input) {
         snapshot.latestSession?.provider === soul.provider.name &&
         (await resolveProviderExecution(soul.provider)).adapter.resume === undefined;
     const facts = await readStatusFacts(paths, input);
-    const selected = selectSnapshot(projectTurns(facts), {
+    const ledger = projectTurns(facts);
+    const selected = selectSnapshot(ledger, {
         aperture: input.aperture,
         budget: ordinarySnapshotBudget(input.ordinaryBudget),
         ...(input.admittedTellId === undefined ? {} : { admittedTellId: input.admittedTellId }),
@@ -78,11 +80,19 @@ export async function bornStatus(paths, expected, input) {
             timeline: selected.snapshot,
         },
         ordinarySelected: selected.ordinaryCount,
+        rows: ledger.rows,
     };
 }
+export async function bornStatus(paths, expected, input) {
+    const { rows: _rows, ...status } = await bornLiveStatus(paths, expected, input);
+    return status;
+}
 export async function readBudgetedStatus(worldPath, id, input) {
     return await bornStatus(pathsForAkuId(worldPath, id), id, input);
 }
+export async function readLiveStatus(worldPath, id, input) {
+    return await bornLiveStatus(pathsForAkuId(worldPath, id), id, input);
+}
 function complete(life, pending) {
     return life !== "running" && !pending;
 }
@@ -95,26 +105,51 @@ export async function readWaitComplete(worldPath, id) {
     return complete(observed.currentLife, observed.snapshot.hasPendingTell);
 }
 const OBSERVATION_POLL_MS = 100;
-function observeDelay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+/**
+ * The one deadline-aware observation loop for public Akuma waiting.  It always
+ * reads once before judging a passed deadline, so a zero-duration wait remains
+ * an honest final snapshot and completion wins at the deadline edge.
+ */
+export async function waitForObservation(input) {
+    const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
+    for (;;) {
+        input.signal?.throwIfAborted();
+        const ready = input.probe === undefined || (await input.probe());
+        input.signal?.throwIfAborted();
+        if (!ready && (deadline === undefined || performance.now() < deadline)) {
+            await abortableDelay(deadline === undefined
+                ? OBSERVATION_POLL_MS
+                : Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
+            continue;
+        }
+        const value = await input.observe();
+        input.signal?.throwIfAborted();
+        await input.onObserve?.(value);
+        if (input.complete(value))
+            return { reason: "completed", value };
+        if (deadline !== undefined && performance.now() >= deadline)
+            return { reason: "deadline", value };
+        await abortableDelay(deadline === undefined
+            ? OBSERVATION_POLL_MS
+            : Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
+    }
 }
 /**
  * Successive status observations of one already born Akuma until its
- * observation window closes. Every status observed while the window is open is
- * reported to `observe`; the window's last status is returned. A window that is
- * already closed, or an Akuma already at its completion judgment, reports
- * nothing and returns the current status.
+ * observation window closes. Every acquired observation is reported to
+ * `observe` before completion or deadline judgment, including the first
+ * already-complete observation; the last status is returned.
  */
 export async function observeAkumaStatus(worldPath, expected, input) {
     const paths = pathsForAkuId(worldPath, expected);
-    const deadline = performance.now() + input.timeoutMs;
-    for (;;) {
-        const status = (await bornStatus(paths, expected, { aperture: "monitoring" })).status;
-        if (defaultWaitComplete(status) || performance.now() >= deadline)
-            return status;
-        input.observe(status);
-        await observeDelay(Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - performance.now())));
-    }
+    const waited = await waitForObservation({
+        timeoutMs: input.timeoutMs,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        observe: async () => await bornLiveStatus(paths, expected, { aperture: "monitoring" }),
+        complete: (observation) => defaultWaitComplete(observation.status),
+        onObserve: input.observe,
+    });
+    return { reason: waited.reason, status: waited.value.status };
 }
 export async function readAkumaBirthCwd(worldPath, id) {
     const soul = await readSoul(pathsForAkuId(worldPath, id));

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

@@ -23,7 +23,6 @@ export type BornAkumaCall = Readonly<{
     initialBody?: string;
     initiator?: string;
     initialSchemaJson?: string;
-    awaitAsleep?: true;
     execution: BornExecution;
 }>;
 export type RequestedAkumaCall = Readonly<{
@@ -51,7 +50,7 @@ declare class AkumaProduct {
     admit(input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaBornCall>;
     publish(born: AkumaBornCall, completion?: Readonly<{
         contractId?: string;
-    }>): Promise<AkumaHandle>;
+    }>, signal?: AbortSignal): Promise<AkumaHandle>;
     [CALL_WITH_CONTEXT](input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
     listComplete(input?: Readonly<{
         archetype?: string;

package/build/src/akuma/akuma-product.js

@@ -27,9 +27,9 @@ async function admitBodyRequest(input) {
         archetype: input.name,
         ...(input.call.body === undefined ? {} : { body: input.call.body }),
         ...(input.call.initiator === undefined ? {} : { initiator: input.call.initiator }),
-        ...(input.call.schema === undefined ? {} : { awaitAsleep: true }),
         ...(cwd === undefined ? {} : { cwd }),
         recipe: input.recipe,
+        ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
     });
     const bornCwd = await readAkumaBirthCwd(input.path, child);
     return {
@@ -45,7 +45,11 @@ async function admitDirect(input) {
     const cwd = input.call.cwd !== undefined && input.context.cwdCanonical === true
         ? input.call.cwd
         : await canonicalBirthCwd(selectedCwd);
-    const allocated = await birthAkuma({ worldPath: input.path, archetype: input.archetype.name });
+    const allocated = await birthAkuma({
+        worldPath: input.path,
+        archetype: input.archetype.name,
+        ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
+    });
     return {
         kind: "born",
         allocated,
@@ -59,7 +63,6 @@ async function admitDirect(input) {
         ...(input.call.body === undefined ? {} : { initialBody: input.call.body }),
         ...(input.call.initiator === undefined ? {} : { initiator: input.call.initiator }),
         ...(input.call.schema === undefined ? {} : { initialSchemaJson: schemaJsonText(input.call.schema) }),
-        ...(input.call.schema === undefined ? {} : { awaitAsleep: true }),
         execution: {
             cwd,
             source: input.call.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
@@ -204,13 +207,13 @@ class AkumaProduct {
             return await admitBodyRequest({ call: input, context, path: this.path, name, recipe: requestRecipe, execution });
         return await admitDirect({ call: input, context, path: this.path, archetype, recipe: requestRecipe });
     }
-    async publish(born, completion = {}) {
+    async publish(born, completion = {}, signal) {
         if (born.kind === "requested") {
             return new AkumaHandle(born.id, this.path, { cwd: born.cwd, source: born.execution.source });
         }
         const published = await launchAkuma({
             allocated: born.allocated,
-            ...(born.awaitAsleep === undefined ? {} : { awaitAsleep: born.awaitAsleep }),
+            ...(signal === undefined ? {} : { signal }),
             launch: async (allocated) => await spawnAkumaBody({
                 paths: allocated.paths,
                 seed: born.seed,

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

@@ -267,6 +267,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
             }, z.core.$strict>]>;
         }, z.core.$strict>]>>>;
         omitted: z.ZodNumber;
+        openingSequence: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             sequence: z.ZodNumber;
@@ -459,6 +460,7 @@ export type AkumaCallInput = Readonly<{
     allowed?: readonly AllowedAction[];
     schema?: Schema<unknown>;
     initiator?: string;
+    signal?: AbortSignal;
 }>;
 export type AkumaCallContext = Readonly<{
     initiatorCwd?: string;

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

@@ -85,4 +85,4 @@ export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch:
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtimeInput?: Partial<BodyRuntime>): Promise<"held" | void>;
 export declare function spawnAkumaBody(launch: BodyLaunch, runtime?: BodyLaunchRuntime): Promise<OwnedProcess>;
 export declare function runAkumaBody(launch: BodyLaunch, world: WorldRoot, externalCommands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
-export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime): Promise<TellResult>;
+export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime, signal?: AbortSignal): Promise<TellResult>;