@astrosheep/keiyaku 4.1.1 → 4.1.2

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

@@ -1,10 +1,15 @@
 import { type TellResult, type TellWakeRuntime } from "./body.js";
-import { type AkumaLife, type KillEvidence, type ResumeCoordinate, type Soul } from "./heart/index.js";
+import { HeldAkumaLeash, type AkumaLife, type KillEvidence, type ResumeCoordinate, type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import { type ActivityHistory, type ActivitySnapshot } from "./projection.js";
-import { type Settings } from "../settings.js";
+import type { ActivitySnapshot } from "./projection.js";
+import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
-import { type AllowedAction } from "./allowed.js";
+import type { AllowedAction } from "./allowed.js";
+export declare const POLL_MS = 100;
+export declare function canonicalBirthCwd(input: string): Promise<string>;
+export declare function callReadonly(value: unknown): Readonly<{
+    readonly?: true;
+}>;
 export type AkumaListRow = Readonly<{
     id: AkuId;
     archetype: string;
@@ -44,8 +49,7 @@ export type AkumaCallExecution = Readonly<{
     cwd: string;
     source: "input" | "caller" | "process" | "world";
 }>;
-declare const CALL_EXECUTION: unique symbol;
-declare const CALL_WITH_CONTEXT: unique symbol;
+export { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
 export type AkumaCallInput = Readonly<{
     archetype: string;
     body: string;
@@ -53,7 +57,7 @@ export type AkumaCallInput = Readonly<{
     readonly?: true;
     allowed?: readonly AllowedAction[];
 }>;
-type AkumaCallContext = Readonly<{
+export type AkumaCallContext = Readonly<{
     initiatorCwd?: string;
     cwdCanonical?: true;
 }>;
@@ -83,11 +87,13 @@ export type ForkReceipt = Readonly<{
     childSession: ResumeCoordinate;
     diagnostic: string;
 }>;
-export declare class AkumaNotBornError extends Error {
-    readonly id: AkuId;
-    readonly kind = "akuma-not-born";
-    constructor(id: AkuId);
-}
+export { AkumaNotBornError } from "./akuma-errors.js";
+export declare function wait(milliseconds: number): Promise<void>;
+export declare function takeLeashUntil(paths: AkumaPaths, deadline: number): Promise<HeldAkumaLeash | null>;
+export declare function recordTellBody(paths: AkumaPaths, akuma: AkuId, body: string, id?: string, recordedAt?: string): Promise<Readonly<{
+    kind: "recorded";
+    tellId: string;
+}>>;
 export declare function tellAkumaWithId(input: Readonly<{
     worldPath: WorldRoot;
     id: AkuId;
@@ -96,65 +102,12 @@ export declare function tellAkumaWithId(input: Readonly<{
     recordedAt?: string;
     runtime?: TellWakeRuntime;
 }>): Promise<TellResult>;
+export declare function diagnostic(error: unknown): string;
 export declare function killAkumaWithRecovery(paths: AkumaPaths, recover?: (paths: AkumaPaths) => Promise<void>): Promise<KillEvidence>;
-export type BudgetedStatusObservation = Readonly<{
-    status: AkumaStatus;
-    ordinarySelected: number;
-}>;
-/** Package-internal observation; Fleet chooses the aperture and ordinary budget. */
-export declare function readBudgetedStatus(worldPath: WorldRoot, id: AkuId, input: Readonly<{
-    aperture: "monitoring" | "receipt";
-    ordinaryBudget?: number;
-}>): Promise<BudgetedStatusObservation>;
-/** Package-internal birth projection used by the composed Library call result. */
-export declare function readAkumaBirthCwd(worldPath: WorldRoot, id: AkuId): Promise<string>;
-export declare class AkumaHandle {
-    readonly id: AkuId;
-    private readonly worldPath;
-    readonly [CALL_EXECUTION]?: AkumaCallExecution;
-    constructor(id: AkuId, worldPath: WorldRoot, execution?: AkumaCallExecution);
-    private get paths();
-    status(): Promise<AkumaStatus>;
-    history(input?: Readonly<{
-        before?: number;
-        since?: number;
-        limit?: number;
-    }>): Promise<ActivityHistory>;
-    wait(predicate?: (status: AkumaStatus) => boolean, options?: Readonly<{
-        timeoutMs?: number;
-    }>): Promise<AkumaStatus>;
-    tell(body: string): Promise<TellResult>;
-    interrupt(body: string): Promise<InterruptReceipt>;
-    fork(input: Readonly<{
-        at: string;
-    }>): Promise<ForkReceipt>;
-    kill(): 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";
-}>;
-type AkumaConfiguration = Readonly<{
+export { bornStatus, fleetListRow, readAkumaBirthCwd, readBudgetedStatus, type BudgetedStatusObservation, } from "./akuma-observe.js";
+export type AkumaConfiguration = Readonly<{
     home?: string;
     settings?: Settings;
 }>;
-export declare class Akuma {
-    private readonly path;
-    private readonly configuration;
-    private constructor();
-    static of(root: WorldRoot, input?: AkumaConfiguration): Akuma;
-    of(input: Readonly<{
-        id: string;
-    }>): AkumaHandle;
-    listArchetypes(): Promise<readonly string[]>;
-    call(input: AkumaCallInput): Promise<AkumaHandle>;
-    [CALL_WITH_CONTEXT](input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;
-    list(input?: AkumaListInput): Promise<AkumaList>;
-}
-/** Package-internal call path for a composition owner that already canonicalized cwd. */
-export declare function callAkumaWithContext(akuma: Akuma, input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;
+export { AkumaHandle, akumaCallExecution, type LastAnswer } from "./akuma-handle.js";
+export { Akuma, callAkumaWithContext } from "./akuma-product.js";

package/build/src/akuma/akuma.js

@@ -1,18 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { readdir, realpath, stat } from "node:fs/promises";
+import { realpath, stat } from "node:fs/promises";
 import { resolve } from "node:path";
-import { CONTROL_RESPONSE_MS, handoffPendingTells, spawnAkumaBody, wakeRecordedTell, } from "./body.js";
-import { HeldAkumaLeash, activitySlice, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readLastAnsweredTurn, readForkPoint, readKill, readSeal, readSoul, recordTell, requestPause, requestStop, } from "./heart/index.js";
-import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, parseAkuId, pathsForAkuId, archetypeName, } from "./identity.js";
-import { ordinarySnapshotBudget, projectTurns, selectHistory, selectSnapshot, } from "./projection.js";
-import { listArchetypes as readArchetypes, loadArchetype } from "./archetype.js";
-import { publishAkuma } from "./publication.js";
-import { resolveProviderExecution } from "./providers/index.js";
-import { injectedBodyRequests, requestBodyCall } from "./requests.js";
-import { settings as readSettings } from "../settings.js";
-import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
-const POLL_MS = 100;
-async function canonicalBirthCwd(input) {
+import { CONTROL_RESPONSE_MS, handoffPendingTells, wakeRecordedTell, } from "./body.js";
+import { HeldAkumaLeash, readHeart, readKill, recordTell, requestStop, } from "./heart/index.js";
+import { pathsForAkuId } from "./identity.js";
+export const POLL_MS = 100;
+export async function canonicalBirthCwd(input) {
     const selected = resolve(input);
     try {
         const canonical = await realpath(selected);
@@ -24,7 +17,7 @@ async function canonicalBirthCwd(input) {
         throw new Error(`cwd is not an existing directory: ${input}`);
     }
 }
-function callReadonly(value) {
+export function callReadonly(value) {
     if (value === undefined)
         return {};
     if (value !== true)
@@ -36,21 +29,13 @@ export function defaultWaitComplete(status) {
     return (status.life !== "running" &&
         !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
 }
-const CALL_EXECUTION = Symbol("akuma-call-execution");
-const CALL_WITH_CONTEXT = Symbol("akuma-call-with-context");
-export class AkumaNotBornError extends Error {
-    id;
-    kind = "akuma-not-born";
-    constructor(id) {
-        super(`Akuma ${id} is not born`);
-        this.id = id;
-        this.name = "AkumaNotBornError";
-    }
-}
-function wait(milliseconds) {
+export { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
+export { AkumaNotBornError } from "./akuma-errors.js";
+import { AkumaNotBornError } from "./akuma-errors.js";
+export function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-async function takeLeashUntil(paths, deadline) {
+export async function takeLeashUntil(paths, deadline) {
     for (;;) {
         const leash = await HeldAkumaLeash.try(paths);
         if (leash !== null)
@@ -60,7 +45,7 @@ async function takeLeashUntil(paths, deadline) {
         await wait(Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
     }
 }
-async function recordTellBody(paths, akuma, body, id = randomUUID(), recordedAt = new Date().toISOString()) {
+export async function recordTellBody(paths, akuma, body, id = randomUUID(), recordedAt = new Date().toISOString()) {
     const admitted = await recordTell(paths, { kind: "tell", id, body, recordedAt });
     if (admitted.kind === "not-born")
         throw new AkumaNotBornError(akuma);
@@ -71,7 +56,7 @@ export async function tellAkumaWithId(input) {
     const recorded = await recordTellBody(paths, input.id, input.body, input.tellId, input.recordedAt);
     return await wakeRecordedTell(paths, recorded.tellId, input.runtime);
 }
-function diagnostic(error) {
+export function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
 export async function killAkumaWithRecovery(paths, recover = handoffPendingTells) {
@@ -110,407 +95,6 @@ export async function killAkumaWithRecovery(paths, recover = handoffPendingTells
         void recover(paths).catch(() => undefined);
     }
 }
-async function fleetListRow(paths, expected) {
-    const snapshot = await readHeart(paths);
-    if (snapshot.soul !== null)
-        return await bornListRow(paths, expected, snapshot);
-    try {
-        if ((await probeLeash(paths)) === "held")
-            return { id: expected, life: "unborn" };
-        const seal = await readSeal(paths);
-        return seal === null ? { id: expected, life: "unborn" } : { id: expected, life: "stillborn", seal };
-    }
-    catch (error) {
-        if (isHeartAbsent(error))
-            return { id: expected, life: "unborn" };
-        throw error;
-    }
-}
-async function bornListRow(paths, expected, snapshot) {
-    snapshot ??= await readHeart(paths);
-    if (snapshot.soul === null)
-        throw new AkumaNotBornError(expected);
-    if (snapshot.soul.id !== expected)
-        throw new Error("Akuma soul does not match its coordinate");
-    const currentLife = life({
-        leash: await probeLeash(paths),
-        body: snapshot.latestBody,
-        kill: snapshot.latestKill,
-    });
-    return {
-        id: snapshot.soul.id,
-        archetype: snapshot.soul.archetype,
-        ...(snapshot.soul.description === undefined ? {} : { description: snapshot.soul.description }),
-        life: currentLife,
-        lifeAt: lifeAt(currentLife, snapshot.latestBody, snapshot.latestKill, snapshot.soul.createdAt),
-        lastActivityAt: snapshot.lastActivityAt,
-        pending: snapshot.pending.map((tell) => tell.id),
-    };
-}
-async function bornStatus(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 = await readHeart(paths);
-    if (snapshot.soul === null)
-        throw new AkumaNotBornError(expected);
-    const current = await bornListRow(paths, expected, snapshot);
-    const resumeUnsupported = current.life === "stranded" &&
-        snapshot.latestSession?.provider === snapshot.soul.provider.name &&
-        (await resolveProviderExecution(snapshot.soul.provider)).adapter.resume === undefined;
-    const slice = await activitySlice(paths);
-    const selected = selectSnapshot(projectTurns(slice.rows), {
-        aperture: input.aperture,
-        budget: ordinarySnapshotBudget(input.ordinaryBudget),
-    });
-    return {
-        status: {
-            id: current.id,
-            life: current.life,
-            ...(snapshot.soul.readonly === undefined ? {} : { readonly: snapshot.soul.readonly }),
-            ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
-            timeline: selected.snapshot,
-        },
-        ordinarySelected: selected.ordinaryCount,
-    };
-}
-/** Package-internal observation; Fleet chooses the aperture and ordinary budget. */
-export async function readBudgetedStatus(worldPath, id, input) {
-    return await bornStatus(pathsForAkuId(worldPath, id), id, input);
-}
-/** Package-internal birth projection used by the composed Library call result. */
-export async function readAkumaBirthCwd(worldPath, id) {
-    const soul = await readSoul(pathsForAkuId(worldPath, id));
-    if (soul === null)
-        throw new AkumaNotBornError(id);
-    return soul.cwd;
-}
-export class AkumaHandle {
-    id;
-    worldPath;
-    [CALL_EXECUTION];
-    constructor(id, worldPath, execution) {
-        this.id = id;
-        this.worldPath = worldPath;
-        if (execution !== undefined)
-            this[CALL_EXECUTION] = execution;
-    }
-    get paths() {
-        return pathsForAkuId(this.worldPath, this.id);
-    }
-    async status() {
-        return (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status;
-    }
-    async history(input = {}) {
-        if (input.before !== undefined && input.since !== undefined) {
-            throw new TypeError("Akuma history before and since are mutually exclusive");
-        }
-        for (const [name, value] of [
-            ["before", input.before],
-            ["since", input.since],
-        ]) {
-            if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
-                throw new TypeError(`Akuma history ${name} must be a positive safe integer`);
-            }
-        }
-        const limit = input.limit ?? 50;
-        if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 5_000) {
-            throw new TypeError("Akuma history limit must be a positive safe integer no greater than 5000");
-        }
-        const slice = await activitySlice(this.paths);
-        return selectHistory(projectTurns(slice.rows, {
-            lowestRetained: slice.lowestRetained,
-            highest: slice.highest,
-        }), {
-            ...(input.before === undefined ? {} : { before: input.before }),
-            ...(input.since === undefined ? {} : { since: input.since }),
-            limit,
-        });
-    }
-    async wait(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 (;;) {
-            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())));
-        }
-    }
-    async tell(body) {
-        const recorded = await recordTellBody(this.paths, this.id, body);
-        return await wakeRecordedTell(this.paths, recorded.tellId);
-    }
-    async interrupt(body) {
-        const request = await requestPause(this.paths, new Date().toISOString());
-        if (request.kind === "not-born") {
-            throw new AkumaNotBornError(this.id);
-        }
-        let putDown = "was-idle";
-        let leash = await HeldAkumaLeash.try(this.paths);
-        if (leash === null) {
-            leash = await takeLeashUntil(this.paths, performance.now() + CONTROL_RESPONSE_MS);
-            putDown = "self-aborted";
-        }
-        if (leash === null) {
-            const body = (await readHeart(this.paths)).latestBody;
-            return {
-                kind: "unavailable",
-                evidence: body?.sequence === request.body.sequence && body.hung !== undefined ? "hung" : "unavailable",
-            };
-        }
-        const settledBody = (await readHeart(this.paths)).latestBody;
-        if (settledBody?.sequence === request.body.sequence && settledBody.hung !== undefined) {
-            try {
-                await leash.clearPause(this.paths);
-            }
-            finally {
-                leash.release();
-            }
-            return { kind: "unavailable", evidence: "hung" };
-        }
-        if (settledBody?.sequence !== request.body.sequence || settledBody.end === undefined) {
-            try {
-                await leash.clearPause(this.paths);
-            }
-            finally {
-                leash.release();
-            }
-            return { kind: "unavailable", evidence: "untidy" };
-        }
-        if (request.body.end !== undefined || settledBody.end !== "put-down")
-            putDown = "was-idle";
-        let recorded;
-        try {
-            const id = randomUUID();
-            const admitted = await leash.recordInterruptTell(this.paths, {
-                kind: "tell",
-                id,
-                body,
-                recordedAt: new Date().toISOString(),
-            });
-            if (admitted.kind === "not-born")
-                throw new AkumaNotBornError(this.id);
-            recorded = { kind: "recorded", tellId: admitted.tell.id };
-        }
-        finally {
-            leash.release();
-        }
-        return { kind: "interrupted", putDown, tell: await wakeRecordedTell(this.paths, recorded.tellId) };
-    }
-    async fork(input) {
-        const source = await readSoul(this.paths);
-        if (source === null)
-            throw new AkumaNotBornError(this.id);
-        if (source.id !== this.id)
-            throw new Error("Akuma soul does not match its coordinate");
-        const adapter = (await resolveProviderExecution(source.provider)).adapter;
-        if (adapter.fork === undefined)
-            return { kind: "provider-cannot-fork", provider: source.provider.name };
-        const point = await readForkPoint(this.paths, input.at);
-        if (point === null)
-            return { kind: "unknown-history", at: input.at };
-        if (point.provider !== source.provider.name)
-            throw new Error(`Akuma fork point ${input.at} has a mismatched provider`);
-        let childSession;
-        try {
-            childSession = (await adapter.fork({ session: point.session, at: point.historyId, cwd: point.cwd })).session;
-        }
-        catch (error) {
-            return { kind: "fork-failed", diagnostic: diagnostic(error) };
-        }
-        const admittedAt = new Date().toISOString();
-        const birthSession = {
-            provider: point.provider,
-            coordinate: childSession,
-            cwd: point.cwd,
-            options: point.options,
-            admittedAt,
-        };
-        try {
-            const child = await publishAkuma({
-                worldPath: this.worldPath,
-                archetype: source.archetype,
-                awaitAsleep: true,
-                launch: async (allocated) => {
-                    (await spawnAkumaBody({
-                        paths: allocated.paths,
-                        seed: {
-                            id: allocated.id,
-                            archetype: source.archetype,
-                            ...(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 },
-                        },
-                        birthSession,
-                    })).release();
-                },
-            });
-            return { kind: "forked", child: child.id };
-        }
-        catch (error) {
-            return {
-                kind: "upstream-forked",
-                childSession,
-                diagnostic: diagnostic(error),
-            };
-        }
-    }
-    async kill() {
-        return await killAkumaWithRecovery(this.paths);
-    }
-    async lastAnswer() {
-        const turn = await readLastAnsweredTurn(this.paths);
-        return turn?.end?.outcome.kind === "answered"
-            ? { kind: "answer", answer: turn.end.outcome.answer }
-            : { kind: "no-answer" };
-    }
-}
-/** Package-internal provenance retained only by the handle returned from call. */
-export function akumaCallExecution(handle) {
-    return handle[CALL_EXECUTION];
-}
-export class Akuma {
-    path;
-    configuration;
-    constructor(path, configuration) {
-        this.path = path;
-        this.configuration = configuration;
-    }
-    static of(root, input = {}) {
-        if (typeof root !== "string")
-            throw new TypeError("Akuma.of root must be a WorldRoot");
-        return new Akuma(root, input);
-    }
-    of(input) {
-        return new AkumaHandle(parseAkuId(input.id).id, this.path);
-    }
-    async listArchetypes() {
-        return readArchetypes(this.configuration.home === undefined ? {} : { home: this.configuration.home });
-    }
-    async call(input) {
-        return await this[CALL_WITH_CONTEXT](input, { initiatorCwd: process.cwd() });
-    }
-    async [CALL_WITH_CONTEXT](input, context) {
-        const readonly = callReadonly(input.readonly);
-        const name = archetypeName(input.archetype);
-        const home = this.configuration.home === undefined ? {} : { home: this.configuration.home };
-        const settings = this.configuration.settings ?? (await readSettings({ root: this.path, ...home }));
-        const archetype = await loadArchetype({
-            name,
-            ...home,
-            settings,
-            ...readonly,
-        });
-        const allowed = input.allowed === undefined
-            ? archetype.allowed
-            : unionAllowedActions(archetype.allowed, decodeAllowedActions(input.allowed, "Akuma call allowed"));
-        const requests = injectedBodyRequests();
-        const requestRecipe = Object.freeze({
-            ...(archetype.description === undefined ? {} : { description: archetype.description }),
-            provider: archetype.provider,
-            options: archetype.options,
-            ...(archetype.readonly === undefined ? {} : { readonly: archetype.readonly }),
-            allowed,
-        });
-        if (requests !== null) {
-            const cwd = input.cwd === undefined
-                ? undefined
-                : context?.cwdCanonical === true
-                    ? input.cwd
-                    : await canonicalBirthCwd(input.cwd);
-            const child = await requestBodyCall({
-                directory: requests,
-                id: randomUUID(),
-                world: this.path,
-                archetype: name,
-                body: input.body,
-                ...(cwd === undefined ? {} : { cwd }),
-                recipe: requestRecipe,
-            });
-            const bornCwd = await readAkumaBirthCwd(this.path, child);
-            return new AkumaHandle(child, this.path, {
-                cwd: bornCwd,
-                source: cwd === undefined ? "caller" : "input",
-            });
-        }
-        const initiatorCwd = context.initiatorCwd;
-        const selectedCwd = input.cwd ?? initiatorCwd ?? this.path;
-        const cwd = input.cwd !== undefined && context?.cwdCanonical === true ? input.cwd : await canonicalBirthCwd(selectedCwd);
-        const recipe = requestRecipe;
-        const published = await publishAkuma({
-            worldPath: this.path,
-            archetype: archetype.name,
-            launch: async (allocated) => {
-                (await spawnAkumaBody({
-                    paths: allocated.paths,
-                    seed: {
-                        id: allocated.id,
-                        archetype: allocated.archetype,
-                        ...recipe,
-                        cwd,
-                        origin: { kind: "direct" },
-                    },
-                    initialBody: input.body,
-                })).release();
-            },
-        });
-        return new AkumaHandle(published.id, this.path, {
-            cwd,
-            source: input.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
-        });
-    }
-    async list(input = {}) {
-        if (typeof input !== "object" || input === null || Array.isArray(input)) {
-            throw new TypeError("Akuma list input must be an object");
-        }
-        const unknown = Object.keys(input).find((key) => key !== "archetype");
-        if (unknown !== undefined)
-            throw new TypeError(`Akuma list input has unknown field: ${unknown}`);
-        const selected = input.archetype === undefined ? undefined : archetypeName(input.archetype);
-        const runRoot = akumaRunRoot(this.path);
-        let names;
-        try {
-            names = (await readdir(runRoot, { withFileTypes: true }))
-                .filter((entry) => entry.isDirectory())
-                .map((entry) => entry.name)
-                .sort();
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                return { rows: [], searched: [runRoot] };
-            throw error;
-        }
-        const rows = [];
-        for (const name of names) {
-            let physical;
-            try {
-                physical = akuIdFromDirectoryName(name);
-            }
-            catch {
-                continue;
-            }
-            if (selected !== undefined && physical.archetype !== selected)
-                continue;
-            const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
-            try {
-                rows.push(await fleetListRow(paths, physical.id));
-            }
-            catch { }
-        }
-        return {
-            rows,
-            searched: [runRoot],
-        };
-    }
-}
-/** Package-internal call path for a composition owner that already canonicalized cwd. */
-export async function callAkumaWithContext(akuma, input, context) {
-    return await akuma[CALL_WITH_CONTEXT](input, context);
-}
+export { bornStatus, fleetListRow, readAkumaBirthCwd, readBudgetedStatus, } from "./akuma-observe.js";
+export { AkumaHandle, akumaCallExecution } from "./akuma-handle.js";
+export { Akuma, callAkumaWithContext } from "./akuma-product.js";

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

@@ -0,0 +1,26 @@
+import { type HeartSnapshot, type HeldAkumaLeash } from "./heart/index.js";
+import type { AkumaPaths } from "./identity.js";
+export declare const CONTROL_RESPONSE_MS = 1000;
+export declare class BodySupervisor {
+    private readonly paths;
+    private readonly bodySequence;
+    private readonly leash;
+    readonly signal: AbortSignal;
+    private readonly controller;
+    private readonly finished;
+    private readonly observer;
+    private waiter;
+    private observation;
+    private stopping?;
+    private constructor();
+    static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash): Promise<BodySupervisor>;
+    get reason(): "control" | "heart-gone" | undefined;
+    current(): HeartSnapshot;
+    recordHung(diagnostic: string, at: string): Promise<void>;
+    refresh(): Promise<HeartSnapshot>;
+    next(after: HeartSnapshot): Promise<HeartSnapshot>;
+    cancel(reason: "control" | "heart-gone"): void;
+    close(): Promise<void>;
+    private publish;
+    private observe;
+}