@astrosheep/keiyaku 4.4.0 → 4.5.1

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

@@ -1,13 +1,10 @@
-import { type KillEvidence, type RequestFact, type Soul } from "./heart/index.js";
-import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type KillEvidence, type RequestFact } from "./heart/index.js";
+import { type AkuId } from "./identity.js";
 import { type StructuralRequestClaim } from "./request-wire.js";
 import { type TaskMutationRequest } from "../task/mutation.js";
-import type { OwnedProcess } from "../runtime/proc/run.js";
-export type RequestChildLaunch = Readonly<{
-    paths: AkumaPaths;
-    seed: Omit<Soul, "createdAt">;
-    initialBody: string;
-}>;
+import { BodyRequestPump as LifecycleBodyRequestPump, type RequestChildLaunch as LifecycleRequestChildLaunch, type PumpInput as LifecyclePumpInput } from "./request-lifecycle.js";
+export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
+export type RequestChildLaunch = LifecycleRequestChildLaunch;
 type UpstreamCall = Readonly<{
     signal: AbortSignal;
 }>;
@@ -60,17 +57,12 @@ export type UpstreamExecutionPort = Readonly<{
         request: TaskMutationRequest;
     }>): Promise<unknown>;
 }>;
-type PumpInput = Readonly<{
-    paths: AkumaPaths;
-    parent: Soul;
-    bodySequence: number;
-    now(): string;
-    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
+type PumpInput = Omit<LifecyclePumpInput, "upstream"> & Readonly<{
     upstream?: UpstreamExecutionPort;
-    signal: AbortSignal;
 }>;
 export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
     directory: string;
+    transportId: string;
     claim: StructuralRequestClaim;
     admissionOpen(): boolean;
 }>;
@@ -79,22 +71,7 @@ export type UpstreamFact = Exclude<Extract<RequestFact, {
 }>, Extract<RequestFact, {
     action: "akuma.call";
 }>>;
-export declare class BodyRequestPump {
-    private readonly input;
-    readonly directory: string;
-    readonly failure: Promise<never>;
-    private readonly closeSignal;
-    private readonly executionSignal;
-    private readonly handled;
-    private readonly running;
-    private readonly cancelBody;
-    private admissionClosed;
-    private constructor();
+export declare function serveRequest(input: ServeInput): Promise<void>;
+export declare class BodyRequestPump extends LifecycleBodyRequestPump {
     static open(input: PumpInput): Promise<BodyRequestPump>;
-    private run;
-    close(): Promise<void>;
-    stopAdmission(): void;
 }
-export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
-export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
-export {};

package/build/src/akuma/request-serve.js

@@ -1,19 +1,26 @@
-import { access, mkdir, readFile, readdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { abortableDelay } from "./abort.js";
-import { HeldAkumaLeash, admitRequest, readNonterminalRequests, readRequest, readSoul, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
-import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
-import { BIRTH_TIMEOUT_MS, publishAkuma } from "./publication.js";
-import { atomicJson, canonicalAkuId, decodeClaim, decodeRecipe, receiptPath, } from "./request-wire.js";
+import { admitRequest, readRequest, refuseRequest, reserveRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
+import { worldRootForAkumaPaths } from "./identity.js";
+import { publishAkuma } from "./publication.js";
+import { atomicJson, canonicalAkuId, decodeRecipe, receiptPath, } from "./request-wire.js";
 import { isTaskMutationAction } from "../task/mutation.js";
 import { executeRequest } from "./request-execution.js";
-const POLL_MS = 100;
+import { BodyRequestPump as LifecycleBodyRequestPump, } from "./request-lifecycle.js";
+export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function isTask(value) {
     return isTaskMutationAction(value.action);
 }
+function refusalRecipe(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        const recipe = value;
+        if (Array.isArray(recipe.allowed))
+            return recipe;
+        return { ...recipe, allowed: [] };
+    }
+    return { allowed: [] };
+}
 function acceptedReceipt(fact, service) {
     return {
         id: fact.id,
@@ -62,7 +69,7 @@ function receiptFor(fact) {
     }
     return null;
 }
-async function projectReceipt(directory, fact, outcome) {
+async function projectReceipt(directory, transportId, fact, outcome) {
     const receipt = outcome === undefined
         ? receiptFor(fact)
         : fact.action === "akuma.call"
@@ -71,29 +78,45 @@ async function projectReceipt(directory, fact, outcome) {
     if (receipt === null)
         return;
     try {
-        await atomicJson(receiptPath(directory, fact.id), receipt);
+        await atomicJson(receiptPath(directory, transportId), receipt);
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
 }
+async function refuseInvalidCall(input) {
+    let fact = await admitRequest(input.paths, {
+        ...input.claim,
+        recipe: refusalRecipe(input.claim.recipe),
+        admittedAt: input.now(),
+    });
+    const existing = receiptFor(fact);
+    if (existing !== null) {
+        await projectReceipt(input.directory, input.transportId, fact);
+        return;
+    }
+    fact = await refuseRequest(input.paths, input.claim.id, "invalid akuma.call recipe");
+    await projectReceipt(input.directory, input.transportId, fact);
+}
 async function serveCall(input) {
     input.signal.throwIfAborted();
     if (!input.admissionOpen())
         return;
     const recipe = decodeRecipe(input.claim.recipe);
-    if (recipe === null)
+    if (recipe === null) {
+        await refuseInvalidCall(input);
         return;
+    }
     let fact = await admitRequest(input.paths, { ...input.claim, recipe, admittedAt: input.now() });
     const existing = receiptFor(fact);
     if (existing !== null) {
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (!input.admissionOpen()) {
         fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (fact.action !== "akuma.call" || fact.state !== "admitted") {
@@ -103,7 +126,7 @@ async function serveCall(input) {
     const world = worldRootForAkumaPaths(input.paths);
     if (request.world !== world) {
         fact = await refuseRequest(input.paths, request.id, `request world ${request.world} does not match ${world}`);
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     try {
@@ -111,14 +134,10 @@ async function serveCall(input) {
             worldPath: world,
             archetype: request.archetype,
             signal: input.signal,
-            reserve: async (allocated) => {
-                if (!input.admissionOpen())
-                    throw new Error("body closed request admission");
-                fact = await reserveRequest(input.paths, request.id, allocated.id);
-            },
             launch: async (allocated) => {
                 if (!input.admissionOpen())
                     throw new Error("body closed request admission");
+                fact = await reserveRequest(input.paths, request.id, allocated.id);
                 return await input.spawn({
                     paths: allocated.paths,
                     seed: {
@@ -140,7 +159,7 @@ async function serveCall(input) {
                 });
             },
         });
-        fact = await serveRequest(input.paths, request.id, published.id);
+        fact = await serveChildRequest(input.paths, request.id, published.id);
     }
     catch (error) {
         const current = await readRequest(input.paths, request.id);
@@ -151,7 +170,7 @@ async function serveCall(input) {
                 ? await voidRequest(input.paths, request.id, diagnostic(error))
                 : current;
     }
-    await projectReceipt(input.directory, fact);
+    await projectReceipt(input.directory, input.transportId, fact);
 }
 function failure(error) {
     const value = error !== null && typeof error === "object" ? error : null;
@@ -178,11 +197,11 @@ async function serveUpstream(input) {
     });
     const existing = receiptFor(fact);
     if (existing !== null) {
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (fact.state === "served") {
-        await projectReceipt(input.directory, fact, {
+        await projectReceipt(input.directory, input.transportId, fact, {
             kind: "failed",
             failure: {
                 kind: "failed",
@@ -193,7 +212,7 @@ async function serveUpstream(input) {
     }
     if (!input.admissionOpen()) {
         fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (fact.state !== "admitted" || fact.action === "akuma.call") {
@@ -211,171 +230,22 @@ async function serveUpstream(input) {
     catch (error) {
         outcome = { kind: "failed", failure: failure(error) };
         fact = await voidRequest(input.paths, request.id, "body failed before serving the request");
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     fact =
         service === undefined
             ? await voidRequest(input.paths, request.id, "body completed without a durable Contract fact reference")
             : await serveUpstreamRequest(input.paths, request.id, service);
-    await projectReceipt(input.directory, fact, outcome);
+    await projectReceipt(input.directory, input.transportId, fact, outcome);
 }
-async function serve(input) {
+export async function serveRequest(input) {
     return input.claim.action === "akuma.call"
         ? await serveCall({ ...input, claim: input.claim })
         : await serveUpstream({ ...input, claim: input.claim });
 }
-async function requestFiles(directory) {
-    try {
-        return (await readdir(directory)).filter((name) => name.endsWith(".request.json")).sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
-export class BodyRequestPump {
-    input;
-    directory;
-    failure;
-    closeSignal = new AbortController();
-    executionSignal = new AbortController();
-    handled = new Set();
-    running;
-    cancelBody;
-    admissionClosed = false;
-    constructor(input) {
-        this.input = input;
-        this.directory = join(input.paths.directory, "requests", String(input.bodySequence));
-        this.cancelBody = () => {
-            this.stopAdmission();
-            if (!this.executionSignal.signal.aborted) {
-                this.executionSignal.abort(input.signal.reason);
-            }
-        };
-        input.signal.addEventListener("abort", this.cancelBody, { once: true });
-        if (input.signal.aborted)
-            this.cancelBody();
-        this.running = this.run();
-        this.failure = this.running.then(() => new Promise(() => { }), (error) => Promise.reject(error));
-    }
+export class BodyRequestPump extends LifecycleBodyRequestPump {
     static async open(input) {
-        await mkdir(join(input.paths.directory, "requests", String(input.bodySequence)), { recursive: true });
-        return new BodyRequestPump(input);
-    }
-    async run() {
-        while (!this.closeSignal.signal.aborted) {
-            for (const name of await requestFiles(this.directory)) {
-                if (this.closeSignal.signal.aborted)
-                    return;
-                const id = name.slice(0, -".request.json".length);
-                if (this.handled.has(id))
-                    continue;
-                const path = join(this.directory, name);
-                const claim = decodeClaim(await readFile(path, "utf8"), id);
-                if (claim === null) {
-                    await rm(path, { force: true });
-                    this.handled.add(id);
-                    continue;
-                }
-                if (!this.admissionClosed) {
-                    await serve({
-                        directory: this.directory,
-                        claim,
-                        ...this.input,
-                        signal: this.executionSignal.signal,
-                        admissionOpen: () => !this.admissionClosed,
-                    });
-                }
-                this.handled.add(id);
-            }
-            try {
-                await abortableDelay(POLL_MS, this.closeSignal.signal);
-            }
-            catch (error) {
-                if (this.closeSignal.signal.aborted)
-                    return;
-                throw error;
-            }
-        }
-    }
-    async close() {
-        this.stopAdmission();
-        try {
-            await this.running;
-        }
-        finally {
-            this.input.signal.removeEventListener("abort", this.cancelBody);
-            await rm(this.directory, { recursive: true, force: true });
-        }
-    }
-    stopAdmission() {
-        this.admissionClosed = true;
-        if (!this.closeSignal.signal.aborted) {
-            this.closeSignal.abort(new Error("Body request pump closed"));
-        }
-    }
-}
-export async function clearBodyRequestTransport(paths) {
-    await rm(join(paths.directory, "requests"), { recursive: true, force: true });
-}
-function matchingRequestOrigin(soul, parent, id) {
-    return soul.origin.kind === "request" && soul.origin.parent === parent && soul.origin.requestId === id;
-}
-async function settleReservedSoul(paths, parent, request, soul) {
-    await (matchingRequestOrigin(soul, parent.id, request.id)
-        ? serveRequest(paths, request.id, request.child)
-        : voidRequest(paths, request.id, "reserved child origin does not match the request"));
-}
-async function settleReserved(paths, parent, request, now, signal) {
-    const childPaths = pathsForAkuId(request.world, request.child);
-    const deadline = performance.now() + BIRTH_TIMEOUT_MS;
-    for (;;) {
-        signal?.throwIfAborted();
-        if (!(await access(childPaths.directory).then(() => true, () => false))) {
-            await voidRequest(paths, request.id, "reserved child directory is absent");
-            return true;
-        }
-        const soul = await readSoul(childPaths);
-        if (soul !== null) {
-            await settleReservedSoul(paths, parent, request, soul);
-            return true;
-        }
-        const leash = await HeldAkumaLeash.try(childPaths);
-        if (leash !== null) {
-            try {
-                const settled = await readSoul(childPaths);
-                if (settled !== null) {
-                    await settleReservedSoul(paths, parent, request, settled);
-                }
-                else {
-                    await leash.sealIfUnborn(childPaths, {
-                        evidence: "request settlement",
-                        at: now(),
-                    });
-                    await voidRequest(paths, request.id, "reserved child was sealed unborn");
-                }
-            }
-            finally {
-                leash.release();
-            }
-            return true;
-        }
-        if (performance.now() >= deadline)
-            return false;
-        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
-    }
-}
-export async function settleBodyRequests(paths, parent, now, signal) {
-    let pending = false;
-    for (const request of await readNonterminalRequests(paths)) {
-        signal?.throwIfAborted();
-        if (request.state === "admitted") {
-            await voidRequest(paths, request.id, "body died before serving the request");
-        }
-        else if (request.state === "reserved" && !(await settleReserved(paths, parent, request, now, signal)))
-            pending = true;
+        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveRequest(claim)));
     }
-    return pending ? "pending" : "settled";
 }

package/build/src/akuma/request-wire.js

@@ -210,7 +210,7 @@ export function decodeClaim(bytes, fileId) {
     const value = object(decoded);
     if (value === null ||
         !exactKeys(value, ["action", "id", "payload"]) ||
-        value.id !== fileId ||
+        !UUID.test(fileId) ||
         typeof value.id !== "string" ||
         !UUID.test(value.id))
         return null;

package/build/src/akuma/requests.js

@@ -26,12 +26,13 @@ export function injectedBodyRequests() {
 }
 async function requestBody(input) {
     input.signal?.throwIfAborted();
-    await atomicJson(requestPath(input.directory, input.claim.id), {
+    const transportId = randomUUID();
+    await atomicJson(requestPath(input.directory, transportId), {
         id: input.claim.id,
         action: input.claim.action,
         payload: requestPayload(input.claim),
     });
-    const path = receiptPath(input.directory, input.claim.id);
+    const path = receiptPath(input.directory, transportId);
     for (;;) {
         try {
             const receipt = decodeReceipt(await readFile(path, "utf8"), input.claim.id, input.claim.action);

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -1,8 +1,9 @@
-import { type AkuId, type ActivityHistory, type ResultRoute } from "../../akuma/index.js";
+import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
 import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
 import type { InvokedAkumaCommand } from "./akuma.js";
+import { finishCall } from "../../library/akuma-creation.js";
 export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
@@ -55,6 +56,13 @@ export type AkumaInvocationResult = Readonly<{
     mode: "no-answer";
     historyResult: AkumaHistoryResult;
     alias?: string;
+}> | Readonly<{
+    kind: "akuma";
+    action: "history";
+    akuma: AkuId;
+    mode: "exact";
+    historyResult: AkumaHistoryResult;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "fork";
@@ -72,8 +80,9 @@ type InvokeInput = Readonly<{
     settings?: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
-    resultRoute?: ResultRoute;
+    environment: NodeJS.ProcessEnv;
     readStdin(): Promise<string>;
+    finishCall?: typeof finishCall;
 }>;
 export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
 export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;

package/build/src/cli/commands/akuma-invoke.js

@@ -1,4 +1,6 @@
 import { Keiyaku, } from "../../index.js";
+import { beginCall, finishCall } from "../../library/akuma-creation.js";
+import { recognizeAndListen } from "../square-edge.js";
 function inputAlias(selector) {
     return selector.startsWith("@") ? selector : undefined;
 }
@@ -56,6 +58,7 @@ async function invokeHistory(command, input) {
         ...(command.before === undefined ? {} : { before: command.before }),
         ...(command.since === undefined ? {} : { since: command.since }),
         ...(command.limit === undefined ? {} : { limit: command.limit }),
+        ...(command.id === undefined ? {} : { id: command.id }),
         last: command.last,
     });
     return {
@@ -64,11 +67,13 @@ async function invokeHistory(command, input) {
         akuma: result.id,
         historyResult: result,
         ...(inputAlias(command.akuma) === undefined ? {} : { alias: command.akuma }),
-        ...(result.kind === "history"
-            ? { mode: "page", history: result.history }
-            : result.kind === "last"
-                ? { mode: "last", answer: result.answer }
-                : { mode: "no-answer" }),
+        ...(command.id !== undefined
+            ? { mode: "exact" }
+            : result.kind === "history"
+                ? { mode: "page", history: result.history }
+                : result.kind === "last"
+                    ? { mode: "last", answer: result.answer }
+                    : { mode: "no-answer" }),
     };
 }
 async function invokeFork(command, input) {
@@ -100,7 +105,7 @@ export async function invokeAkuma(command, input) {
     switch (command.command) {
         case "call": {
             const body = await promptBody(command, input);
-            const result = await Keiyaku.call({
+            const born = await beginCall({
                 path: input.path,
                 archetype: command.archetype,
                 body,
@@ -113,8 +118,25 @@ export async function invokeAkuma(command, input) {
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
                 ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
-                ...(input.resultRoute === undefined ? {} : { resultRoute: input.resultRoute }),
             });
+            const listener = born.born.kind === "born"
+                ? await recognizeAndListen(input.path, input.environment, born.born.allocated)
+                : undefined;
+            let result;
+            try {
+                result = await (input.finishCall ?? finishCall)(born);
+            }
+            catch (error) {
+                if (listener?.committed === true) {
+                    try {
+                        await listener.rollback();
+                    }
+                    catch {
+                        /* preserve launch failure */
+                    }
+                }
+                throw error;
+            }
             return { kind: "akuma", action: "call", result, world: input.path };
         }
         case "wait":

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

@@ -38,6 +38,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
 }> & Addressed & Prompted) | (Readonly<{
     command: "history";
     last: boolean;
+    id?: string;
     before?: number;
     since?: number;
     limit?: number;

package/build/src/cli/commands/akuma.js

@@ -3,6 +3,7 @@ import { parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
 import { decodeAllowedActions } from "../../akuma/allowed.js";
+import { parsePublicHistoryId } from "../../akuma/identity.js";
 const AKUMA_COMMAND_SPECS = {
     call: {
         arity: 1,
@@ -49,8 +50,8 @@ const AKUMA_COMMAND_SPECS = {
     history: {
         arity: 1,
         stdin: false,
-        flags: { before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
-        usage: "history <aku/...|@alias|kei/...> [--before <index> | --since <index>] [--limit <count>] [--last]",
+        flags: { id: "value", before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
+        usage: "history <aku/...|@alias|kei/...> [--id <historyId> | --before <index> | --since <index>] [--limit <count>] [--last]",
         purpose: "Read Akuma execution history or one complete Contract journal and Dispatch timeline.",
     },
     fork: {
@@ -203,22 +204,31 @@ function parseWait(rawSelectors, flags, output, fail) {
 }
 function parseHistory(selector, flags, output, fail) {
     if (selector.startsWith("kei/")) {
-        if (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined || flags.last === true) {
-            fail("history kei/... does not accept --before, --since, --limit, or --last");
+        if ([flags.id, flags.before, flags.since, flags.limit, flags.last].some((value) => value !== undefined)) {
+            fail("history kei/... does not accept --id, --before, --since, --limit, or --last");
         }
         return { command: "history", contract: selector, output };
     }
+    return parseAkumaHistory(selector, flags, output, fail);
+}
+function parseAkumaHistory(selector, flags, output, fail) {
+    const bounded = flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined;
     if (flags.before !== undefined && flags.since !== undefined)
         fail("history --before and --since are mutually exclusive");
-    if (flags.last === true && (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined)) {
+    if (flags.id !== undefined && (flags.last === true || bounded))
+        fail("history --id cannot be combined with --last, --before, --since, or --limit");
+    if (flags.last === true && bounded)
         fail("history --last cannot be combined with --before, --since, or --limit");
-    }
     const limit = flags.limit === undefined ? undefined : positiveIndex(flags.limit, "--limit", fail);
     if (limit !== undefined && limit > 5_000)
         fail("--limit must be no greater than 5000");
+    const id = flags.id === undefined ? undefined : stringFlag(flags.id, "history --id requires a nonblank historyId", fail);
+    if (id !== undefined && parsePublicHistoryId(id) === null)
+        fail("history --id requires turn/<positive safe integer>");
     return {
         command: "history",
         akuma: validateDirect(selector, fail),
+        ...(id === undefined ? {} : { id }),
         last: flags.last === true,
         ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
         ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),

package/build/src/cli/commands/contract.d.ts

@@ -56,6 +56,7 @@ export type ParsedAbandon = Output & Actor & Readonly<{
 export type ParsedStatus = Output & (Readonly<{
     command: "status";
     contract?: string;
+    selectors?: readonly string[];
     akuma?: never;
 }> | Readonly<{
     command: "status";
@@ -178,8 +179,8 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly flags: {
             readonly json: "boolean";
         };
-        readonly usage: "status [<contract>|@name|<aku/...>]";
-        readonly purpose: "Read the world status board or one Contract projection.";
+        readonly usage: "status [<contract>|@name|<aku/...>]...";
+        readonly purpose: "Read the world status board or one or more Contract and Akuma projections.";
     };
     readonly show: {
         readonly positional: "optional";

package/build/src/cli/commands/contract.js

@@ -87,8 +87,8 @@ export const CONTRACT_COMMAND_SPECS = {
         positional: "optional",
         stdin: "none",
         flags: { json: "boolean" },
-        usage: "status [<contract>|@name|<aku/...>]",
-        purpose: "Read the world status board or one Contract projection.",
+        usage: "status [<contract>|@name|<aku/...>]...",
+        purpose: "Read the world status board or one or more Contract and Akuma projections.",
     },
     show: {
         positional: "optional",
@@ -244,6 +244,9 @@ function parseReview(parts) {
     };
 }
 function parseStatus(parts) {
+    if (parts.positionals.length > 1) {
+        return { command: "status", selectors: parts.positionals, output: parts.output };
+    }
     const contract = parts.positionals[0];
     if (contract?.startsWith("aku/") === true) {
         return { command: "status", contract, akuma: true, output: parts.output };

package/build/src/cli/commands/status-set.d.ts

@@ -0,0 +1,4 @@
+import type { StatusSetResult } from "../result.js";
+import type { Repo } from "../../library/repo.js";
+import type { WorldRoot } from "../../world.js";
+export declare function invokeStatusSet(selectors: readonly string[], world: WorldRoot | null, repo: Repo | undefined): Promise<StatusSetResult>;