@astrosheep/keiyaku 4.5.28 → 4.6.1

package/build/src/akuma/{akuma-handle.d.ts → akuma-owner.d.ts}

@@ -1,24 +1,51 @@
+import type { WorldRoot } from "../world.js";
+import { type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
+import type { AkumaStatus } from "./akuma.js";
 import { type TellResult, type TellWakeRuntime } from "./body.js";
-import { HeldAkumaLeash, type KillEvidence, type TellFact, type TurnOutcome } from "./heart/index.js";
+import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
+import { HeldAkumaLeash, type KillEvidence, type ResumeCoordinate, type TellFact, type TurnOutcome } 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;
-export declare function settleAkumaKill(paths: AkumaPaths, signal?: AbortSignal, retainLeash?: boolean): Promise<Readonly<{
-    evidence: KillEvidence;
-    leash?: HeldAkumaLeash;
-}>>;
-export declare function killAkumaWithRecovery(paths: AkumaPaths, recover?: (paths: AkumaPaths) => Promise<void>, signal?: AbortSignal): Promise<KillEvidence>;
-export type TellAdmission = Readonly<{
+import type { ActivityHistory, ExactHistory } from "./projection.js";
+export type InterruptReceipt = Readonly<{
+    kind: "unavailable";
+    evidence: "hung" | "untidy" | "unavailable";
+}> | Readonly<{
+    kind: "interrupted";
+    putDown: "was-idle" | "self-aborted";
+    tell: TellResult;
+}>;
+export type ForkReceipt = Readonly<{
+    kind: "forked";
+    child: AkuId;
+}> | Readonly<{
+    kind: "provider-cannot-fork";
+    provider: string;
+}> | Readonly<{
+    kind: "unknown-history";
+    at: string;
+}> | Readonly<{
+    kind: "fork-failed";
+    diagnostic: string;
+}> | Readonly<{
+    kind: "upstream-forked";
+    childSession: ResumeCoordinate;
+    diagnostic: string;
+}>;
+export type LastAnswer = Readonly<{
+    kind: "answer";
+    answer: string;
+}> | Readonly<{
+    kind: "no-answer";
+}>;
+type TellAdmission = Readonly<{
     kind: "not-born";
 }> | Readonly<{
     kind: "admitted";
     tell: TellFact;
     wake: Promise<TellResult>;
 }>;
-export type InterruptAdmission = Readonly<{
+type InitialTellAdmission = CallInitialTellAdmission;
+type InterruptAdmission = Readonly<{
     kind: "unavailable";
     evidence: "hung" | "untidy" | "unavailable";
 }> | Readonly<{
@@ -27,11 +54,21 @@ export type InterruptAdmission = Readonly<{
     putDown: "was-idle" | "self-aborted";
     wake: Promise<TellResult>;
 }>;
-export declare class AkumaHandle {
+export declare function settleAkumaKill(paths: AkumaPaths, signal?: AbortSignal, retainLeash?: boolean): Promise<Readonly<{
+    evidence: KillEvidence;
+    leash?: HeldAkumaLeash;
+}>>;
+export declare function killAkumaWithRecovery(paths: AkumaPaths, recover?: (paths: AkumaPaths) => Promise<void>, signal?: AbortSignal): Promise<KillEvidence>;
+/**
+ * The one lower native Akuma owner: standalone identity, plural selection and
+ * the request service all consume these same single-target algorithms. It reads
+ * only Heart, leash, provider and filesystem state; optional Alias, Dispatch,
+ * Task and Contract associations are composed above this boundary.
+ */
+export declare class AkumaOwner {
     readonly id: AkuId;
     private readonly worldPath;
-    readonly [CALL_EXECUTION]?: AkumaCallExecution;
-    constructor(id: AkuId, worldPath: WorldRoot, execution?: AkumaCallExecution);
+    constructor(id: AkuId, worldPath: WorldRoot);
     private get paths();
     private projectHistoryTurns;
     private exactHistory;
@@ -53,6 +90,10 @@ export declare class AkumaHandle {
         timeoutMs?: number;
         signal?: AbortSignal;
     }>): Promise<AkumaStatus>;
+    admitInitialTell(initialTell: CallInitialTell, options?: Readonly<{
+        signal?: AbortSignal;
+        runtime?: TellWakeRuntime;
+    }>): Promise<InitialTellAdmission>;
     tell(body: string, tellId?: string, recordedAt?: string, runtime?: TellWakeRuntime, options?: Readonly<{
         schemaJson?: string;
         initiator?: string;
@@ -78,10 +119,11 @@ export declare class AkumaHandle {
     tellOutcome(tellId: string, options?: Readonly<{
         timeoutMs?: number;
         signal?: AbortSignal;
-        observe?: (observation: import("./akuma-observe.js").LiveStatusObservation) => void | Promise<void>;
+        observe?: (observation: LiveStatusObservation) => void | Promise<void>;
     }>): Promise<Readonly<{
         reason: WaitReason;
         outcome: TurnOutcome | null;
+        completedAt: string | null;
     }>>;
     private boundTellOutcome;
     interrupt(body: string, options?: Readonly<{
@@ -110,12 +152,5 @@ export declare class AkumaHandle {
     }>): Promise<KillEvidence>;
     lastAnswer(): Promise<LastAnswer>;
 }
-/** Package-internal provenance retained only by the handle returned from call. */
-export declare function akumaCallExecution(handle: AkumaHandle): AkumaCallExecution | undefined;
-export type LastAnswer = Readonly<{
-    kind: "answer";
-    answer: string;
-}> | Readonly<{
-    kind: "no-answer";
-}>;
 export {};
+/** The alias and Dispatch association an upper caller resolves for one observed Akuma. */

package/build/src/akuma/{akuma-handle.js → akuma-owner.js}

@@ -1,15 +1,15 @@
 import { randomUUID } from "node:crypto";
-import { handoffPendingTells, wakeRecordedTell } from "./body.js";
-import { HeldAkumaLeash, activitySlice, readForkPoint, readHeart, readKill, readLastAnsweredTurn, readSoul, readTell, readTurn, recordTell, requestPause, requestStop, projectTell, } from "./heart/index.js";
+import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
+import { bornLiveStatus, bornStatus, defaultWaitComplete, waitForObservation, } from "./akuma-observe.js";
+import { executeWaitAkuma } from "./akuma-wait.js";
+import { handoffPendingTells, spawnAkumaBody, wakeRecordedTell, } from "./body.js";
+import { admitCallInitialTell } from "./call-initial-tell.js";
 import { acquireLeash } from "./control.js";
+import { HeldAkumaLeash, activitySlice, projectTell, readForkPoint, readHeart, readKill, readLastAnsweredTurn, readSoul, readTell, readTurn, recordTell, requestPause, requestStop, } from "./heart/index.js";
 import { parsePublicHistoryId, pathsForAkuId } from "./identity.js";
-import { projectTurns, selectHistory, selectExactHistory, } from "./projection.js";
+import { projectTurns, selectExactHistory, selectHistory } from "./projection.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { publishAkuma } from "./publication.js";
-import { spawnAkumaBody } from "./body.js";
-import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
-import { bornStatus, bornLiveStatus, defaultWaitComplete, readWaitComplete, waitForObservation, } from "./akuma-observe.js";
-const CALL_EXECUTION = Symbol("akuma-call-execution");
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -79,15 +79,18 @@ export async function killAkumaWithRecovery(paths, recover, signal) {
             void recover(paths).catch(() => undefined);
     }
 }
-export class AkumaHandle {
+/**
+ * The one lower native Akuma owner: standalone identity, plural selection and
+ * the request service all consume these same single-target algorithms. It reads
+ * only Heart, leash, provider and filesystem state; optional Alias, Dispatch,
+ * Task and Contract associations are composed above this boundary.
+ */
+export class AkumaOwner {
     id;
     worldPath;
-    [CALL_EXECUTION];
-    constructor(id, worldPath, execution) {
+    constructor(id, worldPath) {
         this.id = id;
         this.worldPath = worldPath;
-        if (execution !== undefined)
-            this[CALL_EXECUTION] = execution;
     }
     get paths() {
         return pathsForAkuId(this.worldPath, this.id);
@@ -136,20 +139,28 @@ export class AkumaHandle {
         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 waited = await waitForObservation({
+        const waited = await executeWaitAkuma({
+            path: this.worldPath,
+            ids: [this.id],
+            completion: "all",
             ...(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,
+            ...(predicate === defaultWaitComplete ? {} : { predicate }),
         });
-        return { reason: waited.reason, status: waited.value };
+        return { reason: waited.reason, status: waited.observations[0] };
     }
     async wait(predicate = defaultWaitComplete, options = {}) {
         return (await this.waitReceipt(predicate, options)).status;
     }
+    async admitInitialTell(initialTell, options = {}) {
+        return await admitCallInitialTell({
+            world: this.worldPath,
+            id: this.id,
+            initialTell,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            wake: (tell) => wakeRecordedTell(this.paths, tell.id, options.runtime, options.signal),
+        });
+    }
     async tell(body, tellId = randomUUID(), recordedAt = new Date().toISOString(), runtime, options = {}) {
         const admitted = await this.admitTell(body, tellId, recordedAt, runtime, options);
         if (admitted.kind === "not-born")
@@ -212,17 +223,21 @@ export class AkumaHandle {
                 if (options.observe !== undefined) {
                     await options.observe(await bornLiveStatus(this.paths, this.id, { aperture: "monitoring", admittedTellId: tellId }));
                 }
-                return { outcome, terminalWithoutTurn: tell.state === "told" && tell.binding === undefined };
+                return { ...outcome, terminalWithoutTurn: tell.state === "told" && tell.binding === undefined };
             },
             complete: (observed) => observed.outcome !== null || observed.terminalWithoutTurn,
         });
-        return { reason: waited.reason, outcome: waited.value.outcome };
+        return {
+            reason: waited.reason,
+            outcome: waited.value.outcome,
+            completedAt: waited.value.completedAt,
+        };
     }
     async boundTellOutcome(tell) {
         if (tell.binding === undefined)
-            return null;
-        const turn = await readTurn(this.paths, tell.binding.turnSequence);
-        return turn?.end?.outcome ?? null;
+            return { outcome: null, completedAt: null };
+        const end = (await readTurn(this.paths, tell.binding.turnSequence))?.end;
+        return { outcome: end?.outcome ?? null, completedAt: end?.completedAt ?? null };
     }
     async interrupt(body, options = {}) {
         const admitted = await this.admitInterrupt(body, options);
@@ -331,7 +346,6 @@ export class AkumaHandle {
                             ...(source.description === undefined ? {} : { description: source.description }),
                             provider: source.provider,
                             options: source.options,
-                            ...(source.readonly === undefined ? {} : { readonly: source.readonly }),
                             allowed: source.allowed,
                             cwd: source.cwd,
                             origin: { kind: "fork", parent: this.id, at: input.at },
@@ -360,7 +374,7 @@ export class AkumaHandle {
             : { kind: "no-answer" };
     }
 }
-/** Package-internal provenance retained only by the handle returned from call. */
-export function akumaCallExecution(handle) {
-    return handle[CALL_EXECUTION];
-}
+/* ---------------------------------------------------------------------------
+ * One wait owner and its legitimate observation modes
+ * ------------------------------------------------------------------------ */
+/** The alias and Dispatch association an upper caller resolves for one observed Akuma. */

package/build/src/akuma/akuma-selection-execution.d.ts

@@ -0,0 +1,51 @@
+import type { WorldRoot } from "../world.js";
+import type { LiveStatusObservation } from "./akuma-observe.js";
+import type { AkumaStatus } from "./akuma.js";
+import type { TellResult } from "./body.js";
+import type { Schema } from "./schema.js";
+import type { AkumaAskObservation, AkumaAskResult, AkumaKillResult, AkumaTellResult } from "./selection-observation.js";
+export type AskObserver = Readonly<{
+    admitted?: (tell: TellResult, id: AkumaStatus["id"]) => void | Promise<void>;
+    observe?: (observation: LiveStatusObservation) => void | Promise<void>;
+}>;
+type TellExecutionInput = Readonly<{
+    path: WorldRoot;
+    id: AkumaStatus["id"];
+    body: string;
+    tellId?: string;
+    recordedAt?: string;
+    initiator?: string;
+    signal?: AbortSignal;
+    interrupt?: boolean;
+    onObserve?: AskObserver;
+}>;
+export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
+export declare function decodeAskObservation<T>(observation: AkumaAskObservation, schema: Schema<T>): AkumaAskObservation<T>;
+export declare function observeAdmittedAskAkuma(input: Readonly<{
+    path: WorldRoot;
+    id: AkumaStatus["id"];
+    tellId: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    startedAt?: number;
+    wake?: Promise<TellResult>;
+    /**
+     * The exact receipt of the admission this observation is bound to. The
+     * call-facing seam always supplies it so observation never substitutes a
+     * later Heart read for that invocation's admission evidence. Ordinary
+     * Tell-bound asks may omit it and keep reading the current admitted receipt.
+     */
+    receipt?: TellResult;
+    onObserve?: AskObserver;
+}>): Promise<AkumaAskResult>;
+export declare function executeAskAkuma(input: TellExecutionInput & Readonly<{
+    timeoutMs?: number;
+    schemaJson?: string;
+}>): Promise<AkumaAskResult>;
+type KillExecutionInput = Readonly<{
+    path: WorldRoot;
+    ids: readonly AkumaStatus["id"][];
+    signal?: AbortSignal;
+}>;
+export declare function executeKillAkuma(input: KillExecutionInput): Promise<AkumaKillResult>;
+export {};

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

@@ -0,0 +1,134 @@
+import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
+import { AkumaOwner } from "./akuma-owner.js";
+export async function executeTellAkuma(input) {
+    input.signal?.throwIfAborted();
+    const owner = new AkumaOwner(input.id, input.path);
+    let tell;
+    if (input.interrupt === true) {
+        const interrupted = await owner.interrupt(input.body, {
+            ...(input.tellId === undefined ? {} : { tellId: input.tellId }),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+        if (interrupted.kind === "unavailable")
+            throw new AkumaProviderError(`Tell interrupt unavailable: ${interrupted.evidence}`);
+        tell = interrupted.tell;
+    }
+    else {
+        tell = await owner.tell(input.body, input.tellId, input.recordedAt, undefined, {
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+    }
+    input.signal?.throwIfAborted();
+    return { akuma: input.id, tell };
+}
+function askObservation(observed) {
+    if (observed.outcome === null)
+        return observed.reason === "deadline" ? { reason: "deadline" } : { reason: "unanswered" };
+    if (observed.outcome.kind === "answered")
+        return { reason: "answered", answer: observed.outcome.answerJson ?? observed.outcome.answer };
+    if (observed.outcome.kind === "failed")
+        return { reason: "failed", diagnostic: observed.outcome.diagnostic };
+    return {
+        reason: "invalid-output",
+        diagnostic: observed.outcome.diagnostic,
+        answer: observed.outcome.answer,
+    };
+}
+export function decodeAskObservation(observation, schema) {
+    if (observation.reason !== "answered")
+        return observation;
+    let value = observation.answer;
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch (error) {
+            return {
+                reason: "invalid-output",
+                diagnostic: error instanceof Error ? error.message : "Answer is not valid JSON",
+                answer: typeof observation.answer === "string" ? observation.answer : String(observation.answer),
+            };
+        }
+    }
+    try {
+        return { reason: "answered", answer: schema.decode(value) };
+    }
+    catch (error) {
+        return {
+            reason: "invalid-output",
+            diagnostic: error instanceof Error ? error.message : "Answer failed schema decode",
+            answer: typeof observation.answer === "string" ? observation.answer : String(observation.answer),
+        };
+    }
+}
+export async function observeAdmittedAskAkuma(input) {
+    const owner = new AkumaOwner(input.id, input.path);
+    const tell = input.receipt ?? (await owner.admittedReceipt(input.tellId));
+    await input.onObserve?.admitted?.(tell, input.id);
+    let settled;
+    void input.wake?.then((receipt) => {
+        settled = receipt;
+    }, () => undefined);
+    const admittedAt = Date.parse(tell.row.at);
+    const observedAt = performance.timeOrigin + performance.now();
+    const elapsed = input.startedAt === undefined
+        ? Number.isFinite(admittedAt)
+            ? Math.max(0, observedAt - admittedAt)
+            : 0
+        : Math.max(0, performance.now() - input.startedAt);
+    const observed = await owner.tellOutcome(input.tellId, {
+        ...(input.timeoutMs === undefined ? {} : { timeoutMs: Math.max(0, input.timeoutMs - elapsed) }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        ...(input.onObserve?.observe === undefined ? {} : { observe: input.onObserve.observe }),
+    });
+    return {
+        akuma: input.id,
+        tell: settled ?? tell,
+        observation: askObservation(observed),
+        completedAt: observed.completedAt,
+    };
+}
+export async function executeAskAkuma(input) {
+    input.signal?.throwIfAborted();
+    const owner = new AkumaOwner(input.id, input.path);
+    const admission = input.interrupt === true
+        ? await owner.admitInterrupt(input.body, {
+            ...(input.tellId === undefined ? {} : { tellId: input.tellId }),
+            ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        })
+        : await owner.admitTell(input.body, input.tellId, input.recordedAt, undefined, {
+            ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+    if (admission.kind === "unavailable")
+        throw new AkumaProviderError(`Tell interrupt unavailable: ${admission.evidence}`);
+    if (admission.kind === "not-born")
+        throw new AkumaNotBornError(input.id);
+    return await observeAdmittedAskAkuma({
+        path: input.path,
+        id: input.id,
+        tellId: admission.tell.id,
+        ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+        startedAt: performance.now(),
+        wake: admission.wake,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        ...(input.onObserve === undefined ? {} : { onObserve: input.onObserve }),
+    });
+}
+export async function executeKillAkuma(input) {
+    input.signal?.throwIfAborted();
+    const owners = input.ids.map((id) => new AkumaOwner(id, input.path));
+    const evidence = await Promise.all(owners.map(async (owner) => await owner.kill(input.signal === undefined ? {} : { signal: input.signal })));
+    input.signal?.throwIfAborted();
+    return {
+        results: input.ids.map((id, index) => ({ id, evidence: evidence[index] })),
+    };
+}
+/* ---------------------------------------------------------------------------
+ * Native roster, archetype listing and the one prepared call recipe
+ * ------------------------------------------------------------------------ */

package/build/src/akuma/{fleet-execution.d.ts → akuma-wait.d.ts}

@@ -1,10 +1,10 @@
-import { type AkumaStatus, type TellResult } from "./akuma.js";
-import { type LiveStatusObservation } from "./akuma-observe.js";
-import type { ActivityRow } from "./projection.js";
-import { type DispatchAssociation } from "./dispatch-association.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
-import { type AkumaKillResult, type AkumaTellResult, type AkumaTellWaitResult, type AkumaWaitResult } from "./fleet-observation.js";
+import { type WaitReason } from "./akuma-observe.js";
+import type { AkumaStatus } from "./akuma.js";
+import type { DispatchAssociation } from "./dispatch-association.js";
+import type { ActivityRow } from "./projection.js";
+import type { AkumaUnobserved } from "./selection-observation.js";
 export type WaitIdentityFacts = Readonly<{
     /** The alias currently addressing this Akuma in its world, when one is bound to it. */
     alias?: AkumaAlias;
@@ -25,12 +25,14 @@ export type WaitObserver = Readonly<{
     selected?: (selected: readonly WaitSelectedAkuma[]) => void;
     observe?: (observed: readonly WaitObservedAkuma[]) => void;
 }>;
-export type WaitExecutionInput = Readonly<{
+type WaitExecutionInput = Readonly<{
     path: WorldRoot;
     ids: readonly AkumaStatus["id"][];
     completion: "any" | "all";
     timeoutMs?: number;
     signal?: AbortSignal;
+    /** Internal custom completion judge over the full final observation where supplied. */
+    predicate?: (status: AkumaStatus) => boolean;
     /** Resolves one Akuma's identity facts; consulted once per Akuma a viewer first sees. */
     identity?: (id: AkumaStatus["id"]) => Promise<WaitIdentityFacts>;
     /** The selected set in the caller's order; a viewer's head and scoreboard follow it. */
@@ -40,30 +42,20 @@ export type WaitExecutionInput = Readonly<{
     /** Reports every observation round to a live viewer. */
     observe?: (observed: readonly WaitObservedAkuma[]) => void;
 }>;
-export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<AkumaWaitResult>;
-export type TellWaitObserver = Readonly<{
-    admitted?: (tell: TellResult, id: AkumaStatus["id"]) => void | Promise<void>;
-    observe?: (observation: LiveStatusObservation) => void | Promise<void>;
-}>;
-export type TellExecutionInput = Readonly<{
-    path: WorldRoot;
-    id: AkumaStatus["id"];
-    body: string;
-    tellId?: string;
-    recordedAt?: string;
-    initiator?: string;
-    signal?: AbortSignal;
-    onObserve?: TellWaitObserver;
-}>;
-export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
-export declare function executeTellWaitAkuma(input: TellExecutionInput & Readonly<{
-    timeoutMs: number;
-    schemaJson?: string;
-    interrupt?: boolean;
-}>): Promise<AkumaTellWaitResult>;
-export type KillExecutionInput = Readonly<{
-    path: WorldRoot;
-    ids: readonly AkumaStatus["id"][];
-    signal?: AbortSignal;
+/** One wait's association-free native evidence; upper composition attaches cross-product context. */
+export type NativeWaitResult = Readonly<{
+    mode: "any" | "all";
+    reason: WaitReason;
+    observations: readonly AkumaStatus[];
+    unobserved: readonly AkumaUnobserved[];
 }>;
-export declare function executeKillAkuma(input: KillExecutionInput): Promise<AkumaKillResult>;
+/**
+ * The one lower set-observation owner for Akuma wait completion. It serves the
+ * standalone one-ID association-free face and the plural any/all face with one
+ * ordered round algorithm, one shared ordinary-detail budget, transient
+ * unreadable peers, and an honest final deadline edge. The default completion
+ * probe is used only without live row callbacks and never with a custom
+ * predicate; a live viewer always observes rounds.
+ */
+export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<NativeWaitResult>;
+export {};

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

@@ -0,0 +1,113 @@
+import { AkumaNotBornError } from "./akuma-errors.js";
+import { defaultWaitComplete, readLiveStatus, readWaitComplete, waitForObservation, } from "./akuma-observe.js";
+const SHARED_ORDINARY_BUDGET = 30;
+async function observeWaitRound(path, ids, signal) {
+    signal?.throwIfAborted();
+    if (ids.length <= 1) {
+        const observations = await Promise.all(ids.map(async (id) => await readLiveStatus(path, id, { aperture: "monitoring" })));
+        return { observations, unobserved: [] };
+    }
+    let remaining = SHARED_ORDINARY_BUDGET;
+    const observations = [];
+    const unobserved = [];
+    for (const id of ids) {
+        signal?.throwIfAborted();
+        try {
+            const observed = await readLiveStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
+            observations.push(observed);
+            remaining -= observed.ordinarySelected;
+        }
+        catch (error) {
+            if (error instanceof AkumaNotBornError)
+                throw error;
+            unobserved.push({ id, diagnostic: diagnostic(error) });
+        }
+    }
+    return { observations, unobserved };
+}
+function roundComplete(round, completion, predicate) {
+    const judge = predicate ?? defaultWaitComplete;
+    const settled = round.observations.map((observation) => judge(observation.status));
+    return (settled.length > 0 &&
+        (completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean)));
+}
+/** Canonical ids in the caller's selection order, appending any id the caller never named. */
+function selectionOrderedIds(ids, order) {
+    const present = new Set(ids);
+    const seen = new Set();
+    const ordered = [];
+    for (const id of order) {
+        if (present.has(id) && !seen.has(id)) {
+            seen.add(id);
+            ordered.push(id);
+        }
+    }
+    for (const id of ids) {
+        if (!seen.has(id)) {
+            seen.add(id);
+            ordered.push(id);
+        }
+    }
+    return ordered;
+}
+/**
+ * The one lower set-observation owner for Akuma wait completion. It serves the
+ * standalone one-ID association-free face and the plural any/all face with one
+ * ordered round algorithm, one shared ordinary-detail budget, transient
+ * unreadable peers, and an honest final deadline edge. The default completion
+ * probe is used only without live row callbacks and never with a custom
+ * predicate; a live viewer always observes rounds.
+ */
+export async function executeWaitAkuma(input) {
+    // Identity facts are read once per observed Akuma, not once per 100ms round.
+    const facts = new Map();
+    if (input.onSelected !== undefined) {
+        for (const id of input.ids) {
+            input.signal?.throwIfAborted();
+            const known = input.identity === undefined ? undefined : await input.identity(id);
+            facts.set(id, known ?? { contract: { kind: "none" } });
+        }
+        const ordered = input.selectionOrder === undefined ? input.ids : selectionOrderedIds(input.ids, input.selectionOrder);
+        input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
+    }
+    const observeRound = async (round) => {
+        if (input.observe === undefined)
+            return;
+        const observed = [];
+        for (const observation of round.observations) {
+            input.signal?.throwIfAborted();
+            const { status, rows } = observation;
+            let known = facts.get(status.id);
+            if (known === undefined && input.identity !== undefined) {
+                known = await input.identity(status.id);
+                facts.set(status.id, known);
+            }
+            if (known === undefined) {
+                observed.push({ status, rows, contract: { kind: "none" } });
+                continue;
+            }
+            observed.push({ status, rows, ...known });
+        }
+        input.observe(observed);
+    };
+    const live = input.observe !== undefined;
+    const waited = await waitForObservation({
+        ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        ...(input.predicate === undefined && !live && input.ids.length === 1
+            ? { probe: async () => await readWaitComplete(input.path, input.ids[0]) }
+            : {}),
+        observe: async () => await observeWaitRound(input.path, input.ids, input.signal),
+        complete: (round) => roundComplete(round, input.completion, input.predicate),
+        onObserve: async (round) => await observeRound(round),
+    });
+    return {
+        mode: input.completion,
+        reason: waited.reason,
+        observations: waited.value.observations.map((observation) => observation.status),
+        unobserved: waited.value.unobserved,
+    };
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}