@astrosheep/keiyaku 4.1.0 → 4.1.2

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, spawnAkumaBody } 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 { ordinarySelectedCount, ordinarySnapshotBudget, projectTurns, selectActivitySnapshot, 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, } from "./allowed.js";
-const POLL_MS = 25;
-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,485 +17,84 @@ 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)
         throw new TypeError("Akuma call readonly must be true");
     return { readonly: true };
 }
-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";
-    }
+/** The default completion judgment over one complete status snapshot. */
+export function defaultWaitComplete(status) {
+    return (status.life !== "running" &&
+        !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
 }
-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)
             return leash;
         if (performance.now() >= deadline)
             return null;
-        await wait(POLL_MS);
+        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);
     return { kind: "recorded", tellId: admitted.tell.id };
 }
-async function wakeTell(paths, tellId) {
-    try {
-        await spawnAkumaBody({ paths });
-        return { admission: { tellId, fact: "recorded" }, wake: "spawned" };
-    }
-    catch (error) {
-        return {
-            admission: { tellId, fact: "recorded" },
-            wake: { kind: "failed", diagnostic: diagnostic(error) },
-        };
-    }
-}
-export async function tellAkumaWithId(worldPath, id, body, tellId, recordedAt = new Date().toISOString()) {
-    const paths = pathsForAkuId(worldPath, id);
-    const recorded = await recordTellBody(paths, id, body, tellId, recordedAt);
-    return await wakeTell(paths, recorded.tellId);
+export async function tellAkumaWithId(input) {
+    const paths = pathsForAkuId(input.worldPath, input.id);
+    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);
 }
-async function fleetListRow(paths, expected) {
-    const snapshot = await readHeart(paths);
-    if (snapshot.soul !== null)
-        return await bornListRow(paths, expected, snapshot);
+export async function killAkumaWithRecovery(paths, recover = handoffPendingTells) {
     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, budget) {
-    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);
-    return {
-        id: current.id,
-        life: current.life,
-        ...(snapshot.soul.readonly === undefined ? {} : { readonly: snapshot.soul.readonly }),
-        ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
-        timeline: budget === undefined
-            ? selectActivitySnapshot(slice.rows)
-            : selectSnapshot(projectTurns(slice.rows), budget),
-    };
-}
-/** Package-internal budgeted observation; Fleet allocates, Akuma still selects. */
-export async function readBudgetedStatus(worldPath, id, input) {
-    if (!Number.isSafeInteger(input.ordinaryBudget) || input.ordinaryBudget < 0) {
-        throw new TypeError("ordinary budget must be a nonnegative safe integer");
-    }
-    const status = await bornStatus(pathsForAkuId(worldPath, id), id, ordinarySnapshotBudget(input.ordinaryBudget));
-    return { status, ordinarySelected: ordinarySelectedCount(status.timeline) };
-}
-/** 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);
-    }
-    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 = (status) => status.life !== "running", 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 wakeTell(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 wakeTell(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,
-                }),
-            });
-            return { kind: "forked", child: child.id };
-        }
-        catch (error) {
-            return {
-                kind: "upstream-forked",
-                childSession,
-                diagnostic: diagnostic(error),
-            };
-        }
-    }
-    async kill() {
-        const at = new Date().toISOString();
-        const request = await requestStop(this.paths, at);
+        const request = await requestStop(paths, new Date().toISOString());
         if (request.kind !== "requested")
             return request.kind;
         const target = request.body;
-        const graceDeadline = performance.now() + CONTROL_RESPONSE_MS;
-        const leash = await takeLeashUntil(this.paths, graceDeadline);
-        if (await readKill(this.paths, target.sequence) !== null) {
+        const leash = await takeLeashUntil(paths, performance.now() + CONTROL_RESPONSE_MS);
+        if ((await readKill(paths, target.sequence)) !== null) {
             leash?.release();
             return "killed";
         }
         if (leash === null) {
-            if (await readKill(this.paths, target.sequence) !== null)
+            if ((await readKill(paths, target.sequence)) !== null)
                 return "killed";
-            const body = (await readHeart(this.paths)).latestBody;
+            const body = (await readHeart(paths)).latestBody;
             return body?.sequence === target.sequence && body.hung !== undefined ? "hung" : "unavailable";
         }
         try {
-            const settledBody = (await readHeart(this.paths)).latestBody;
+            const settledBody = (await readHeart(paths)).latestBody;
             if (settledBody?.sequence !== target.sequence)
-                return await readKill(this.paths, target.sequence) === null ? "unavailable" : "killed";
+                return (await readKill(paths, target.sequence)) === null ? "unavailable" : "killed";
             if (settledBody.end !== "put-down") {
-                await leash.clearStop(this.paths);
+                await leash.clearStop(paths);
                 return "untidy";
             }
-            const settled = await leash.settleStop(this.paths, target.sequence);
-            if (settled === null)
-                return "unavailable";
-            return "killed";
+            const settled = await leash.settleStop(paths, target.sequence);
+            return settled === null ? "unavailable" : "killed";
         }
         finally {
             leash.release();
         }
     }
-    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
-            : 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,
-            }),
-        });
-        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],
-        };
+    finally {
+        void recover(paths).catch(() => undefined);
     }
 }
-/** 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/allowed.d.ts

@@ -4,4 +4,5 @@ export type AllowedActions = readonly AllowedAction[];
 export declare function isAllowedAction(value: unknown): value is AllowedAction;
 export declare function decodeAllowedActions(value: unknown, label?: string): AllowedActions;
 export declare function effectiveAllowedActions(value: unknown): AllowedActions;
+export declare function unionAllowedActions(base: AllowedActions, additions: AllowedActions): AllowedActions;
 export declare function clipAllowedActions(requested: AllowedActions, parent: AllowedActions): AllowedActions;

package/build/src/akuma/allowed.js

@@ -27,6 +27,12 @@ export function decodeAllowedActions(value, label = "allowed") {
 export function effectiveAllowedActions(value) {
     return value === undefined ? ALLOWED_ACTIONS : decodeAllowedActions(value);
 }
+export function unionAllowedActions(base, additions) {
+    const merged = new Set(base);
+    for (const action of additions)
+        merged.add(action);
+    return Object.freeze([...merged].sort());
+}
 export function clipAllowedActions(requested, parent) {
     const ceiling = new Set(parent);
     return Object.freeze(requested.filter((action) => ceiling.has(action)));

package/build/src/akuma/archetype.js

@@ -110,10 +110,12 @@ function decodeArchetype(name, path, markdown) {
             ...(model === undefined ? {} : { model }),
             ...(effort === undefined ? {} : { effort }),
             ...(network === undefined ? {} : { network }),
-            ...(systemPrompt.length === 0 ? {} : {
-                systemPrompt,
-                systemPromptMode: systemPromptMode ?? "append",
-            }),
+            ...(systemPrompt.length === 0
+                ? {}
+                : {
+                    systemPrompt,
+                    systemPromptMode: systemPromptMode ?? "append",
+                }),
         }),
         ...(readonly === undefined ? {} : { readonly }),
         allowed,
@@ -142,7 +144,8 @@ export async function listArchetypeDefinitions(input = {}) {
 }
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value : null;
+        ? value
+        : null;
 }
 function optionalProviderText(value, name, field) {
     const selected = value[field];

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;
+}