@astrosheep/keiyaku 4.5.26 → 4.5.27

package/build/src/library/address.js

@@ -1,7 +1,7 @@
 /** @architectureCompositionRoot */
 import { readAliases } from "../alias/index.js";
 import { createAkumaProduct } from "../akuma/akuma-product.js";
-import { probeBornAkuma } from "../akuma/akuma-probe.js";
+import { akumaAddressability, requireBornAkuma } from "../akuma/akuma-probe.js";
 import { parseAkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { readDispatches } from "../dispatch/index.js";
@@ -9,6 +9,16 @@ import { matchesAkumaGlob, parseAkumaAlias, parseAkumaGlob, } from "../identity/
 import { World } from "../world.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
+export class AkumaAddressError extends Error {
+    refusal;
+    constructor(refusal) {
+        super(refusal.kind === "akuma-alias-not-found"
+            ? `unknown Akuma alias: ${refusal.alias}`
+            : `invalid Akuma: ${refusal.selector}`);
+        this.refusal = refusal;
+        this.name = "AkumaAddressError";
+    }
+}
 export class AkumaWorldScopeError extends TypeError {
     refusal;
     constructor(refusal) {
@@ -22,23 +32,43 @@ function nonblank(value, label) {
         throw new TypeError(`${label} must be a nonblank string`);
     return value;
 }
+function parseAddressAlias(selector) {
+    try {
+        return parseAkumaAlias(selector);
+    }
+    catch (error) {
+        if (!(error instanceof TypeError))
+            throw error;
+        throw new AkumaAddressError({ kind: "invalid-akuma", selector });
+    }
+}
+function parseAddressId(selector) {
+    try {
+        return parseAkuId(selector);
+    }
+    catch (error) {
+        if (!(error instanceof TypeError))
+            throw error;
+        throw new AkumaAddressError({ kind: "invalid-akuma", selector });
+    }
+}
 async function directId(path, selector) {
     if (selector.startsWith("@")) {
-        const alias = parseAkumaAlias(selector);
+        const alias = parseAddressAlias(selector);
         const resolved = (await readAliases(path)).find((binding) => binding.alias === alias)?.akuId ?? null;
         if (resolved === null)
-            throw new TypeError(`unknown Akuma alias: ${alias}`);
+            throw new AkumaAddressError({ kind: "akuma-alias-not-found", alias });
         return resolved;
     }
-    return parseAkuId(selector).id;
+    return parseAddressId(selector).id;
 }
 export function resolveNamedAddress(input) {
     const selector = nonblank(input.selector, "selector");
     if (selector.startsWith("kei/"))
         return { kind: "contract", id: contractId(selector) };
     if (selector.startsWith("aku/"))
-        return { kind: "akuma", id: parseAkuId(selector).id };
-    const alias = parseAkumaAlias(selector);
+        return { kind: "akuma", id: parseAddressId(selector).id };
+    const alias = parseAddressAlias(selector);
     const contractMatches = (input.report.contracts.kind === "present" ? input.report.contracts.value.rows : []).filter((row) => row.disposition === "active" &&
         row.workspace === "worktree" &&
         row.worktreePath !== null &&
@@ -62,9 +92,14 @@ export function resolveNamedAddress(input) {
     if (input.aliases.kind === "failed") {
         throw new TypeError("cannot resolve a named selector while Alias authority is failed");
     }
-    throw new TypeError(`unknown selector: ${selector}`);
+    throw new AkumaAddressError({ kind: "akuma-alias-not-found", alias });
 }
-export async function addressAkuma(input) {
+/**
+ * Resolves one selector to a complete identity without proving it born. The
+ * caller is a forwarding boundary: the parent Fleet answers for the target, so
+ * this process must not read its own Heart files to decide.
+ */
+export async function resolveAkuma(input) {
     const values = requireInput(input, "Akuma address input");
     for (const key of Object.keys(values)) {
         if (!["path", "akuma", "repo"].includes(key)) {
@@ -74,7 +109,17 @@ export async function addressAkuma(input) {
     if (values.repo !== undefined)
         scopeForRepo(values.repo);
     const path = await World.prove(nonblank(values.path, "path"));
-    return { path, id: await directId(path, nonblank(values.akuma, "akuma")) };
+    const id = await directId(path, nonblank(values.akuma, "akuma"));
+    return { path, id };
+}
+/**
+ * Resolves one selector against this World, where a local caller is answered
+ * for the target's birth by the one addressability normalization.
+ */
+export async function addressAkuma(input) {
+    const addressed = await resolveAkuma(input);
+    await requireBornAkuma(addressed.path, addressed.id);
+    return addressed;
 }
 function parseSetSelector(raw) {
     const selector = nonblank(raw, "akuma selector");
@@ -83,13 +128,13 @@ function parseSetSelector(raw) {
     if (selector.includes("*"))
         return { kind: "glob", value: parseAkumaGlob(selector) };
     if (selector.startsWith("@"))
-        return { kind: "alias", value: parseAkumaAlias(selector) };
-    return { kind: "direct", value: parseAkuId(selector).id };
+        return { kind: "alias", value: parseAddressAlias(selector) };
+    return { kind: "direct", value: parseAddressId(selector).id };
 }
 function hasSelectorKind(selectors, kind) {
     return selectors.some((selector) => selector.kind === kind);
 }
-function addSelectorIds(selector, sources, selected, contractMembers) {
+function addSelectorIds(selector, sources, selected, contractMembers, explicit) {
     if (selector.kind === "contract") {
         for (const dispatch of sources.dispatches) {
             if (dispatch.contractId !== selector.value)
@@ -108,20 +153,18 @@ function addSelectorIds(selector, sources, selected, contractMembers) {
     if (selector.kind === "alias") {
         const id = sources.aliases.get(selector.value);
         if (id === undefined)
-            throw new TypeError(`unknown Akuma alias: ${selector.value}`);
+            throw new AkumaAddressError({ kind: "akuma-alias-not-found", alias: selector.value });
         selected.add(id);
+        explicit.add(id);
         return;
     }
     selected.add(selector.value);
+    explicit.add(selector.value);
 }
 async function contractMemberInWorld(path, id) {
-    try {
-        return await probeBornAkuma(path, id);
-    }
-    catch {
-        // A dispatched physical member remains selected when its Heart cannot be read.
-        return true;
-    }
+    // A dispatched physical member stays selected when its Heart cannot be read:
+    // the World, not this reader, remains the authority on its membership.
+    return (await akumaAddressability(path, id)).kind !== "absent";
 }
 async function refuseForeignContractMembers(path, ids, contractMembers) {
     const foreign = [];
@@ -132,7 +175,13 @@ async function refuseForeignContractMembers(path, ids, contractMembers) {
     if (foreign.length > 0)
         throw new AkumaWorldScopeError({ kind: "akuma-not-in-world", ids: foreign, world: path });
 }
-export async function addressAkumaSet(input) {
+function canonicalAkumaOrder(selected) {
+    const ids = [...selected].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+    if (ids.length === 0)
+        throw new TypeError("Akuma selector snapshot is empty");
+    return ids;
+}
+async function readAkumaSet(input) {
     const values = requireInput(input, "Akuma set address input");
     for (const key of Object.keys(values)) {
         if (!["path", "akuma", "repo"].includes(key)) {
@@ -157,13 +206,25 @@ export async function addressAkumaSet(input) {
         : [];
     const selected = new Set();
     const contractMembers = new Set();
+    const explicit = new Set();
     const sources = { fleetIds, aliases, dispatches };
     for (const selector of selectors)
-        addSelectorIds(selector, sources, selected, contractMembers);
-    const orderedIds = [...selected];
-    const ids = [...selected].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
-    if (ids.length === 0)
-        throw new TypeError("Akuma selector snapshot is empty");
-    await refuseForeignContractMembers(path, ids, contractMembers);
-    return { path, ids, orderedIds };
+        addSelectorIds(selector, sources, selected, contractMembers, explicit);
+    return { path, orderedIds: [...selected], ids: canonicalAkumaOrder(selected), contractMembers, explicit };
+}
+/**
+ * Resolves a selector set to complete identities without proving any born. The
+ * caller is a forwarding boundary, the parent Fleet owns the answer, and no
+ * member's Heart is read here.
+ */
+export async function resolveAkumaSet(input) {
+    const resolved = await readAkumaSet(input);
+    return { path: resolved.path, ids: resolved.ids, orderedIds: resolved.orderedIds };
+}
+export async function addressAkumaSet(input) {
+    const resolved = await readAkumaSet(input);
+    for (const id of resolved.explicit)
+        await requireBornAkuma(resolved.path, id);
+    await refuseForeignContractMembers(resolved.path, resolved.ids, resolved.contractMembers);
+    return { path: resolved.path, ids: resolved.ids, orderedIds: resolved.orderedIds };
 }

package/build/src/library/composition.d.ts

@@ -191,6 +191,10 @@ export declare function composeLibrary(context?: ExecutionContext, composition?:
                             } | {
                                 kind: "other";
                                 display: string;
+                                input?: {
+                                    json: string;
+                                    truncated: boolean;
+                                } | undefined;
                             };
                             state: "active";
                             truncated?: true | undefined;
@@ -227,6 +231,10 @@ export declare function composeLibrary(context?: ExecutionContext, composition?:
                             } | {
                                 kind: "other";
                                 display: string;
+                                input?: {
+                                    json: string;
+                                    truncated: boolean;
+                                } | undefined;
                             };
                             state: {
                                 status: "error" | "ok";
@@ -317,6 +325,10 @@ export declare function composeLibrary(context?: ExecutionContext, composition?:
                             } | {
                                 kind: "other";
                                 display: string;
+                                input?: {
+                                    json: string;
+                                    truncated: boolean;
+                                } | undefined;
                             };
                             state: {
                                 status: "error" | "ok";

package/build/src/library/fleet.d.ts

@@ -3,8 +3,9 @@ import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type Interrupt
 import { type ExecutionContext } from "../akuma/requests.js";
 import type { WaitObserver } from "../akuma/fleet-execution.js";
 import { type DispatchAssociation } from "../dispatch/index.js";
+import { type Schema } from "../akuma/schema.js";
 import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
-import { type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellResult, type AkumaWaitResult } from "../akuma/fleet-observation.js";
+import { type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellResult, type AkumaTellWaitResult, type AkumaWaitResult } from "../akuma/fleet-observation.js";
 export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
@@ -15,6 +16,14 @@ export type AkumaTellInput = AkumaAddressInput & Readonly<{
     initiator?: string;
     signal?: AbortSignal;
 }>;
+export type AkumaTellWaitInput = AkumaAddressInput & Readonly<{
+    body: string;
+    timeoutMs: number;
+    schema?: Schema<unknown>;
+    interrupt?: boolean;
+    initiator?: string;
+    signal?: AbortSignal;
+}>;
 export type { TellResult, TellWake } from "../akuma/akuma.js";
 export type { CreatedTaskObservation } from "../task/created-observation.js";
 export type { DispatchAssociation } from "../dispatch/association.js";
@@ -68,5 +77,6 @@ export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaObse
 export declare function waitAkuma(input: AkumaWaitInput, execution?: ExecutionContext, observer?: WaitObserver): Promise<AkumaWaitResult>;
 export declare function killAkuma(input: AkumaKillInput, execution?: ExecutionContext): Promise<AkumaKillResult>;
 export declare function tellAkuma(input: AkumaTellInput, execution?: ExecutionContext): Promise<AkumaTellResult>;
+export declare function tellWaitAkuma(input: AkumaTellWaitInput, execution?: ExecutionContext): Promise<AkumaTellWaitResult>;
 export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
 export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;

package/build/src/library/fleet.js

@@ -1,15 +1,17 @@
 /** @architectureCompositionRoot */
 import { AkumaNotBornError, readBudgetedStatus, withoutReportedChanges, } from "../akuma/akuma.js";
+import { AkumaObservationError } from "../akuma/akuma-errors.js";
 import { createAkumaProduct } from "../akuma/akuma-product.js";
 import { executionChannel, localExecutionContext } from "../akuma/requests.js";
-import { requestForwardedFleetKill, requestForwardedFleetTell, requestForwardedFleetWait, } from "../akuma/fleet-request.js";
-import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "../akuma/fleet-execution.js";
+import { requestForwardedFleetKill, requestForwardedFleetTell, requestForwardedFleetTellWait, requestForwardedFleetWait, } from "../akuma/fleet-request.js";
+import { executeKillAkuma, executeTellAkuma, executeTellWaitAkuma, executeWaitAkuma, } from "../akuma/fleet-execution.js";
 import { readAliases } from "../alias/index.js";
 import { observeDispatchAssociation } from "../dispatch/index.js";
 import { observeContractAt } from "../git/observe.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { observeCreatedTaskObservations } from "../task/created-observation.js";
-import { addressAkuma, addressAkumaSet } from "./address.js";
+import { schemaJsonText } from "../akuma/schema.js";
+import { addressAkuma, addressAkumaSet, resolveAkuma, resolveAkumaSet, } from "./address.js";
 import { requireInput } from "./input.js";
 import { fleetResultSchemas, parseAkumaObservation, } from "../akuma/fleet-observation.js";
 import { scopeForRepo } from "./repo.js";
@@ -20,6 +22,11 @@ function source(path) {
 function observationDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function observationError(id, error) {
+    if (error instanceof AkumaNotBornError || error instanceof AkumaObservationError)
+        return error;
+    return new AkumaObservationError(id, observationDiagnostic(error));
+}
 async function dispatchAssociation(repo, id) {
     return await observeDispatchAssociation(repo === undefined ? undefined : scopeForRepo(repo), id);
 }
@@ -153,7 +160,49 @@ function setAddress(values) {
 }
 export async function statusAkuma(input) {
     const addressed = await addressAkuma(input);
-    return await observeAkuma(await source(addressed.path).selectHandle({ id: addressed.id }).status(), addressed.path, input.repo);
+    try {
+        return await observeAkuma(await source(addressed.path).selectHandle({ id: addressed.id }).status(), addressed.path, input.repo);
+    }
+    catch (error) {
+        throw observationError(addressed.id, error);
+    }
+}
+function completionMode(value) {
+    // An omitted mode is any: a plural wait returns when any selected Akuma is complete.
+    if (value === undefined)
+        return "any";
+    if (value !== "any" && value !== "all")
+        throw new TypeError("completion must be any or all");
+    return value;
+}
+async function forwardedWait(addressed, input) {
+    return await attachWaitAssociations(addressed.path, input.repo, await requestForwardedFleetWait({
+        directory: input.directory,
+        targets: addressed.orderedIds,
+        completion: input.completion,
+        ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }));
+}
+async function localWait(addressed, input) {
+    try {
+        return await attachWaitAssociations(addressed.path, input.repo, await executeWaitAkuma({
+            path: addressed.path,
+            ids: addressed.orderedIds,
+            completion: input.completion,
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            identity: waitIdentityFacts(addressed.path, input.repo),
+            selectionOrder: addressed.orderedIds,
+            ...(input.observer?.selected === undefined ? {} : { onSelected: input.observer.selected }),
+            ...(input.observer?.observe === undefined ? {} : { observe: input.observer.observe }),
+        }));
+    }
+    catch (error) {
+        if (input.signal?.aborted === true || addressed.orderedIds.length !== 1)
+            throw error;
+        throw observationError(addressed.orderedIds[0], error);
+    }
 }
 export async function waitAkuma(input, execution = localExecutionContext(), observer) {
     const values = requireInput(input, "Keiyaku.wait input");
@@ -162,37 +211,25 @@ export async function waitAkuma(input, execution = localExecutionContext(), obse
             throw new TypeError(`Keiyaku.wait input has unknown field: ${key}`);
         }
     }
-    const addressed = await addressAkumaSet(setAddress(values));
-    const completion = values.completion;
-    if (completion !== undefined && completion !== "any" && completion !== "all") {
-        throw new TypeError("completion must be any or all");
-    }
-    // An omitted mode is any: a plural wait returns when any selected Akuma is complete.
-    const selected = completion ?? "any";
+    const selected = completionMode(values.completion);
     const timeoutMs = timeout(values.timeoutMs);
     const callerSignal = signal(values.signal);
     const channel = executionChannel(execution);
     const repo = values.repo;
-    if (channel.kind === "body-request") {
-        return await attachWaitAssociations(addressed.path, repo, await requestForwardedFleetWait({
-            directory: channel.directory,
-            targets: addressed.orderedIds,
-            completion: selected,
-            ...(timeoutMs === undefined ? {} : { timeoutMs }),
-            ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-        }));
-    }
-    return await attachWaitAssociations(addressed.path, repo, await executeWaitAkuma({
-        path: addressed.path,
-        ids: addressed.orderedIds,
+    const mode = {
         completion: selected,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
         ...(callerSignal === undefined ? {} : { signal: callerSignal }),
-        identity: waitIdentityFacts(addressed.path, repo),
-        selectionOrder: addressed.orderedIds,
-        ...(observer?.selected === undefined ? {} : { onSelected: observer.selected }),
-        ...(observer?.observe === undefined ? {} : { observe: observer.observe }),
-    }));
+        ...(repo === undefined ? {} : { repo }),
+    };
+    if (channel.kind === "body-request") {
+        // A forwarded operation resolves coordinates without proving birth: the
+        // parent Fleet owns the target, so this process never probes locally.
+        const addressed = await resolveAkumaSet(setAddress(values));
+        return await forwardedWait(addressed, { ...mode, directory: channel.directory });
+    }
+    const addressed = await addressAkumaSet(setAddress(values));
+    return await localWait(addressed, { ...mode, ...(observer === undefined ? {} : { observer }) });
 }
 export async function killAkuma(input, execution = localExecutionContext()) {
     const values = requireInput(input, "Keiyaku.kill input");
@@ -202,15 +239,16 @@ export async function killAkuma(input, execution = localExecutionContext()) {
         }
     }
     const callerSignal = signal(values.signal);
-    const addressed = await addressAkumaSet(setAddress(values));
     const channel = executionChannel(execution);
     if (channel.kind === "body-request") {
+        const addressed = await resolveAkumaSet(setAddress(values));
         return await requestForwardedFleetKill({
             directory: channel.directory,
             targets: addressed.orderedIds,
             ...(callerSignal === undefined ? {} : { signal: callerSignal }),
         });
     }
+    const addressed = await addressAkumaSet(setAddress(values));
     return await executeKillAkuma({
         path: addressed.path,
         ids: addressed.orderedIds,
@@ -227,9 +265,9 @@ export async function tellAkuma(input, execution = localExecutionContext()) {
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
     const callerSignal = signal(values.signal);
-    const addressed = await addressAkuma(directAddress(values));
     const channel = executionChannel(execution);
     if (channel.kind === "body-request") {
+        const addressed = await resolveAkuma(directAddress(values));
         return await requestForwardedFleetTell({
             directory: channel.directory,
             target: addressed.id,
@@ -238,6 +276,7 @@ export async function tellAkuma(input, execution = localExecutionContext()) {
             ...(callerSignal === undefined ? {} : { signal: callerSignal }),
         });
     }
+    const addressed = await addressAkuma(directAddress(values));
     return await executeTellAkuma({
         path: addressed.path,
         id: addressed.id,
@@ -246,6 +285,52 @@ export async function tellAkuma(input, execution = localExecutionContext()) {
         ...(callerSignal === undefined ? {} : { signal: callerSignal }),
     });
 }
+export async function tellWaitAkuma(input, execution = localExecutionContext()) {
+    const values = requireInput(input, "Keiyaku tell wait input");
+    for (const key of Object.keys(values)) {
+        if (!["path", "akuma", "body", "repo", "timeoutMs", "schema", "interrupt", "initiator", "signal"].includes(key)) {
+            throw new TypeError(`Keiyaku tell wait input has unknown field: ${key}`);
+        }
+    }
+    if (typeof values.body !== "string")
+        throw new TypeError("body must be a string");
+    if (typeof values.timeoutMs !== "number" ||
+        !Number.isFinite(values.timeoutMs) ||
+        !Number.isInteger(values.timeoutMs) ||
+        values.timeoutMs < 0) {
+        throw new TypeError("timeoutMs must be a nonnegative finite millisecond duration");
+    }
+    if (values.interrupt !== undefined && typeof values.interrupt !== "boolean")
+        throw new TypeError("interrupt must be a boolean");
+    const callerSignal = signal(values.signal);
+    const channel = executionChannel(execution);
+    if (channel.kind === "body-request") {
+        // A forwarded Tell is resolved by its serving parent, so this process must
+        // not prove the target against its own Heart files.
+        const addressed = await resolveAkuma(directAddress(values));
+        return await requestForwardedFleetTellWait({
+            directory: channel.directory,
+            target: addressed.id,
+            body: values.body,
+            timeoutMs: values.timeoutMs,
+            ...(input.schema === undefined ? {} : { schema: input.schema }),
+            ...(input.interrupt === true ? { interrupt: true } : {}),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(callerSignal === undefined ? {} : { signal: callerSignal }),
+        });
+    }
+    const addressed = await addressAkuma(directAddress(values));
+    return await executeTellWaitAkuma({
+        path: addressed.path,
+        id: addressed.id,
+        body: values.body,
+        timeoutMs: values.timeoutMs,
+        ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
+        ...(input.interrupt === true ? { interrupt: true } : {}),
+        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        ...(callerSignal === undefined ? {} : { signal: callerSignal }),
+    });
+}
 export async function interruptAkuma(input) {
     const values = requireInput(input, "Keiyaku.interrupt input");
     for (const key of Object.keys(values)) {
@@ -284,24 +369,29 @@ export async function historyAkuma(input) {
     const values = requireInput(input, "Keiyaku.history input");
     validateHistoryInput(values);
     const addressed = await addressAkuma(directAddress(values));
-    const handle = source(addressed.path).selectHandle({ id: addressed.id });
-    const contract = await dispatchAssociation(values.repo, addressed.id);
-    if (values.last === true) {
-        const answer = await handle.lastAnswer();
-        return answer.kind === "answer"
-            ? { kind: "last", id: addressed.id, answer: answer.answer, contract }
-            : { kind: "no-answer", id: addressed.id, contract };
+    try {
+        const handle = source(addressed.path).selectHandle({ id: addressed.id });
+        const contract = await dispatchAssociation(values.repo, addressed.id);
+        if (values.last === true) {
+            const answer = await handle.lastAnswer();
+            return answer.kind === "answer"
+                ? { kind: "last", id: addressed.id, answer: answer.answer, contract }
+                : { kind: "no-answer", id: addressed.id, contract };
+        }
+        const history = await handle.history({
+            ...(values.id === undefined ? {} : { id: values.id }),
+            ...(values.before === undefined ? {} : { before: values.before }),
+            ...(values.since === undefined ? {} : { since: values.since }),
+            ...(values.limit === undefined ? {} : { limit: values.limit }),
+        });
+        if (values.id !== undefined) {
+            if ("kind" in history && history.kind === "exact")
+                return { kind: "exact", id: addressed.id, outcome: history.outcome, contract };
+            return { kind: "unknown-history", id: addressed.id, historyId: values.id, contract };
+        }
+        return { kind: "history", id: addressed.id, history: history, contract };
     }
-    const history = await handle.history({
-        ...(values.id === undefined ? {} : { id: values.id }),
-        ...(values.before === undefined ? {} : { before: values.before }),
-        ...(values.since === undefined ? {} : { since: values.since }),
-        ...(values.limit === undefined ? {} : { limit: values.limit }),
-    });
-    if (values.id !== undefined) {
-        if ("kind" in history && history.kind === "exact")
-            return { kind: "exact", id: addressed.id, outcome: history.outcome, contract };
-        return { kind: "unknown-history", id: addressed.id, historyId: values.id, contract };
+    catch (error) {
+        throw observationError(addressed.id, error);
     }
-    return { kind: "history", id: addressed.id, history: history, contract };
 }

package/build/src/library/keiyaku.d.ts

@@ -223,6 +223,10 @@ export declare const Keiyaku: Readonly<{
                             } | {
                                 kind: "other";
                                 display: string;
+                                input?: {
+                                    json: string;
+                                    truncated: boolean;
+                                } | undefined;
                             };
                             state: "active";
                             truncated?: true | undefined;
@@ -259,6 +263,10 @@ export declare const Keiyaku: Readonly<{
                             } | {
                                 kind: "other";
                                 display: string;
+                                input?: {
+                                    json: string;
+                                    truncated: boolean;
+                                } | undefined;
                             };
                             state: {
                                 status: "error" | "ok";
@@ -349,6 +357,10 @@ export declare const Keiyaku: Readonly<{
                             } | {
                                 kind: "other";
                                 display: string;
+                                input?: {
+                                    json: string;
+                                    truncated: boolean;
+                                } | undefined;
                             };
                             state: {
                                 status: "error" | "ok";

package/build/src/plugin/public.d.ts

@@ -26,6 +26,7 @@ export type PluginSignalMap = Readonly<{
     }>;
     "akuma.turn-outcome": Readonly<{
         akumaId: string;
+        bodySequence: number;
         turnSequence: number;
         initiator?: string;
         outcome: PluginOutcome;
@@ -35,6 +36,7 @@ export type PluginSignalMap = Readonly<{
         akumaId: string;
         bodySequence: number;
         end: PluginBodyEnd;
+        initiator?: string;
         diagnostic?: string;
         contractId?: string;
     }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.26",
+  "version": "4.5.27",
   "workspaces": [
     "plugins/*"
   ],