@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/akuma/akuma.js

@@ -0,0 +1,414 @@
+import { randomUUID } from "node:crypto";
+import { readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { spawnAkumaBody } from "./body.js";
+import { HeldAkumaLeash, activitySlice, life, 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 { projectActivityHistory, selectActivitySnapshot, } from "./projection.js";
+import { listArchetypes as readArchetypes, loadArchetype } from "./archetype.js";
+import { publishAkuma } from "./publication.js";
+import { providerNamed } from "./providers/index.js";
+import { injectedBodyRequests, requestBodyCall } from "./requests.js";
+import { probeProcessTree, putDownProcessTree } from "../runtime/proc/run.js";
+import { settings as readSettings } from "../settings.js";
+const POLL_MS = 25;
+const KILL_GRACE_MS = 1_000;
+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) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function takeLeashUntil(paths, deadline) {
+    for (;;) {
+        const leash = HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        if (performance.now() >= deadline)
+            return null;
+        await wait(POLL_MS);
+    }
+}
+function recordTellBody(paths, akuma, body) {
+    const id = randomUUID();
+    const admitted = recordTell(paths, { kind: "tell", id, body, recordedAt: new Date().toISOString() });
+    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: error instanceof Error ? error.message : String(error) },
+        };
+    }
+}
+function collarProbe(snapshot) {
+    if (snapshot.latestBody === null)
+        return { kind: "gone", end: null };
+    const probe = probeProcessTree(snapshot.latestBody.collar);
+    if (probe.kind === "gone")
+        return { kind: "gone", end: snapshot.latestBody.end ?? null };
+    return probe;
+}
+function bornListRow(paths, expected, snapshot = 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 collar = collarProbe(snapshot);
+    return {
+        id: snapshot.soul.id,
+        archetype: snapshot.soul.archetype,
+        ...(snapshot.soul.description === undefined ? {} : { description: snapshot.soul.description }),
+        life: life(probeLeash(paths), collar, snapshot.latestBody, snapshot.latestKill),
+        collar,
+        confinement: snapshot.soul.confinement,
+        pending: snapshot.pending.map((tell) => tell.id),
+    };
+}
+function bornStatus(paths, expected, profile = "status") {
+    const snapshot = readHeart(paths);
+    if (snapshot.soul === null)
+        throw new AkumaNotBornError(expected);
+    const current = bornListRow(paths, expected, snapshot);
+    const resumeUnsupported = current.life === "stranded"
+        && snapshot.latestSession?.provider === snapshot.soul.provider.name
+        && providerNamed(snapshot.soul.provider).resume === undefined;
+    return {
+        id: current.id,
+        life: current.life,
+        collar: current.collar,
+        ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
+        timeline: (() => {
+            const slice = activitySlice(paths, { limit: Number.MAX_SAFE_INTEGER });
+            return selectActivitySnapshot(slice.rows, {
+                lowestRetained: slice.lowestRetained,
+                highest: slice.highest,
+                profile,
+            });
+        })(),
+    };
+}
+/** Package-internal compact observation for action feedback. */
+export function readActionFeedbackStatus(worldPath, id) {
+    return bornStatus(pathsForAkuId(worldPath, id), id, "feedback");
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export class AkumaHandle {
+    id;
+    worldPath;
+    constructor(id, worldPath) {
+        this.id = id;
+        this.worldPath = worldPath;
+    }
+    get paths() {
+        return pathsForAkuId(this.worldPath, this.id);
+    }
+    status() {
+        return bornStatus(this.paths, this.id);
+    }
+    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 = activitySlice(this.paths, {
+            ...(input.before === undefined ? {} : { before: input.before }),
+            ...(input.since === undefined ? {} : { since: input.since }),
+            limit: 5_000,
+        });
+        return projectActivityHistory(slice, {
+            ...(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 = 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 = recordTellBody(this.paths, this.id, body);
+        return await wakeTell(this.paths, recorded.tellId);
+    }
+    async interrupt(body) {
+        if (requestPause(this.paths, new Date().toISOString()).kind === "not-born") {
+            throw new AkumaNotBornError(this.id);
+        }
+        let putDown = "was-idle";
+        let leash = HeldAkumaLeash.try(this.paths);
+        if (leash === null) {
+            leash = await takeLeashUntil(this.paths, performance.now() + KILL_GRACE_MS);
+            putDown = "self-aborted";
+        }
+        if (leash === null) {
+            const current = readHeart(this.paths).latestBody;
+            if (current === null)
+                return { kind: "unstoppable", evidence: "no-collar" };
+            if (probeProcessTree(current.collar).kind === "unverifiable") {
+                return { kind: "unstoppable", evidence: "collar-unverifiable" };
+            }
+            const evidence = await putDownProcessTree(current.collar);
+            if (evidence === "unavailable" || evidence === "alive-after-sigkill") {
+                return { kind: "unstoppable", evidence };
+            }
+            leash = await takeLeashUntil(this.paths, performance.now() + KILL_GRACE_MS);
+            if (leash === null)
+                return { kind: "unstoppable", evidence: "leash-held-after-put-down" };
+            putDown = "collar";
+        }
+        let recorded;
+        try {
+            const id = randomUUID();
+            const admitted = 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 = 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 = providerNamed(source.provider);
+        if (adapter.fork === undefined)
+            return { kind: "provider-cannot-fork", provider: source.provider.name };
+        const point = 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,
+                        cwd: source.cwd,
+                        origin: { kind: "fork", parent: this.id, at: input.at },
+                        confinement: source.confinement,
+                    },
+                    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 = requestStop(this.paths, at);
+        if (request.kind === "already-killed")
+            return "already-killed";
+        const target = request.body;
+        const graceDeadline = performance.now() + KILL_GRACE_MS;
+        while (probeLeash(this.paths) === "held" && performance.now() < graceDeadline)
+            await wait(POLL_MS);
+        if (readKill(this.paths, target.sequence) !== null)
+            return "killed";
+        const targetProbe = probeProcessTree(target.collar);
+        if (targetProbe.kind === "unverifiable")
+            return "unavailable";
+        if (targetProbe.kind === "alive") {
+            const evidence = await putDownProcessTree(target.collar);
+            if (evidence === "unavailable" || evidence === "alive-after-sigkill")
+                return evidence;
+        }
+        const leash = await takeLeashUntil(this.paths, performance.now() + KILL_GRACE_MS);
+        if (leash === null)
+            return readKill(this.paths, target.sequence) === null ? "unavailable" : "killed";
+        try {
+            const settled = leash.settleStop(this.paths, target.sequence);
+            if (settled === null)
+                return "unavailable";
+            return "killed";
+        }
+        finally {
+            leash.release();
+        }
+    }
+    lastAnswer() {
+        const turn = readLastAnsweredTurn(this.paths);
+        return turn?.end?.outcome.kind === "answered"
+            ? { kind: "answer", answer: turn.end.outcome.answer }
+            : { kind: "no-answer" };
+    }
+}
+export class Akuma {
+    path;
+    configuredSettings;
+    constructor(path, configuredSettings) {
+        this.path = path;
+        this.configuredSettings = configuredSettings;
+    }
+    static of(root, settings) {
+        if (typeof root !== "string")
+            throw new TypeError("Akuma.of root must be a WorldRoot");
+        return new Akuma(root, settings);
+    }
+    settings() {
+        return this.configuredSettings ?? readSettings({ root: this.path });
+    }
+    of(input) {
+        return new AkumaHandle(parseAkuId(input.id).id, this.path);
+    }
+    listArchetypes() {
+        return readArchetypes({ settings: this.settings() });
+    }
+    async call(input) {
+        const name = archetypeName(input.archetype);
+        const archetype = loadArchetype({ name, settings: this.settings() });
+        const provider = archetype.adapter;
+        const cwd = resolve(input.cwd ?? this.path);
+        const recipe = Object.freeze({
+            ...(archetype.description === undefined ? {} : { description: archetype.description }),
+            provider: archetype.provider,
+            options: archetype.options,
+            confinement: provider.confinement({ cwd, options: archetype.options }),
+        });
+        const requests = injectedBodyRequests();
+        if (requests !== null) {
+            const child = await requestBodyCall({
+                directory: requests,
+                id: randomUUID(),
+                world: this.path,
+                archetype: name,
+                body: input.body,
+                cwd,
+                recipe,
+            });
+            return new AkumaHandle(child, this.path);
+        }
+        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,
+                    ...(archetype.description === undefined ? {} : { description: archetype.description }),
+                    provider: archetype.provider,
+                    options: archetype.options,
+                    cwd,
+                    origin: { kind: "direct" },
+                    confinement: recipe.confinement,
+                },
+                initialBody: input.body,
+            }),
+        });
+        return new AkumaHandle(published.id, this.path);
+    }
+    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 = readdirSync(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 = names.flatMap((name) => {
+            try {
+                const physical = akuIdFromDirectoryName(name);
+                if (selected !== undefined && physical.archetype !== selected)
+                    return [];
+                const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
+                const snapshot = readHeart(paths);
+                if (snapshot.soul !== null)
+                    return [bornListRow(paths, physical.id, snapshot)];
+                if (probeLeash(paths) === "held")
+                    return [{ id: physical.id, life: "unborn" }];
+                const seal = readSeal(paths);
+                return seal === null
+                    ? [{ id: physical.id, life: "unborn" }]
+                    : [{ id: physical.id, life: "stillborn", seal }];
+            }
+            catch {
+                return [];
+            }
+        });
+        return {
+            rows,
+            searched: [runRoot],
+        };
+    }
+}

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

@@ -0,0 +1,39 @@
+import type { Settings } from "../settings.js";
+import { type ProviderAdapter, type ProviderOptions } from "./provider.js";
+import type { ProviderExecution } from "./heart/index.js";
+type DecodedArchetype = Readonly<{
+    name: string;
+    path: string;
+    provider: string;
+    description?: string;
+    options: ProviderOptions;
+}>;
+export type ArchetypeCatalogRow = Readonly<{
+    name: string;
+    model?: string;
+    description?: string;
+}>;
+type ArchetypeDefinition = DecodedArchetype & Readonly<{
+    adapter: ProviderAdapter;
+}>;
+type AdmittedArchetype = Omit<ArchetypeDefinition, "provider"> & Readonly<{
+    provider: ProviderExecution;
+}>;
+export declare class AkumaArchetypeError extends Error {
+    readonly archetype: string;
+    readonly searched: readonly string[];
+    readonly reason: string;
+    readonly kind = "akuma-archetype";
+    constructor(archetype: string, searched: readonly string[], reason: string);
+}
+export declare function listArchetypes(input: Readonly<{
+    settings: Settings;
+}>): readonly string[];
+export declare function listArchetypeDefinitions(input: Readonly<{
+    settings: Settings;
+}>): readonly ArchetypeCatalogRow[];
+export declare function loadArchetype(input: Readonly<{
+    name: string;
+    settings: Settings;
+}>): AdmittedArchetype;
+export {};

package/build/src/akuma/archetype.js

@@ -0,0 +1,207 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseDocument } from "yaml";
+import { archetypeName } from "./identity.js";
+import { decodeProviderOptions } from "./provider.js";
+import { decodeProviderExecution, providerNamed } from "./providers/index.js";
+export class AkumaArchetypeError extends Error {
+    archetype;
+    searched;
+    reason;
+    kind = "akuma-archetype";
+    constructor(archetype, searched, reason) {
+        super(`Akuma archetype ${archetype} ${reason}\n${searched.map((path) => `searched ${path}`).join("\n")}`);
+        this.archetype = archetype;
+        this.searched = searched;
+        this.reason = reason;
+        this.name = "AkumaArchetypeError";
+    }
+}
+function archetypeDirectory(settings) {
+    const userPath = settings.scopes.user.path;
+    return userPath === undefined ? null : join(dirname(userPath), "akuma");
+}
+function archetypePaths(settings) {
+    const directory = archetypeDirectory(settings);
+    if (directory === null)
+        return [];
+    try {
+        return readdirSync(directory, { withFileTypes: true })
+            .flatMap((entry) => {
+            if (!entry.isFile() || !entry.name.endsWith(".md"))
+                return [];
+            const name = entry.name.slice(0, -3);
+            try {
+                return [{ name: archetypeName(name), path: join(directory, entry.name) }];
+            }
+            catch {
+                return [];
+            }
+        })
+            .sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export function listArchetypes(input) {
+    return archetypePaths(input.settings).map(({ name }) => name);
+}
+function archetypeField(values, key, required = false) {
+    const value = values[key];
+    if (value === undefined && !required)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError(`Archetype ${key} must be a nonblank string`);
+    }
+    return value;
+}
+function archetypeEnum(values, key, allowed) {
+    const value = archetypeField(values, key);
+    if (value === undefined)
+        return undefined;
+    if (!allowed.includes(value))
+        throw new TypeError(`Archetype ${key} must be one of ${allowed.join(", ")}`);
+    return value;
+}
+function decodeArchetype(name, path, markdown) {
+    const lines = markdown.split(/\r?\n/u);
+    if (lines[0]?.trim() !== "---")
+        throw new TypeError("Archetype must begin with YAML frontmatter");
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing < 0)
+        throw new TypeError("Archetype frontmatter is not closed");
+    const document = parseDocument(lines.slice(1, closing).join("\n"), { uniqueKeys: true });
+    if (document.errors.length > 0)
+        throw new TypeError(`Archetype frontmatter is invalid: ${document.errors[0].message}`);
+    const decoded = document.toJS();
+    if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded)) {
+        throw new TypeError("Archetype frontmatter must be one mapping");
+    }
+    const values = decoded;
+    const provider = archetypeField(values, "provider", true);
+    const model = archetypeField(values, "model");
+    const effort = archetypeField(values, "effort");
+    const access = archetypeEnum(values, "access", ["read", "write", "auto"]);
+    const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
+    const description = archetypeField(values, "description");
+    const systemPrompt = lines.slice(closing + 1).join("\n");
+    return Object.freeze({
+        name,
+        path,
+        provider,
+        ...(description === undefined ? {} : { description }),
+        options: decodeProviderOptions({
+            ...(model === undefined ? {} : { model }),
+            ...(effort === undefined ? {} : { effort }),
+            ...(access === undefined ? {} : { access }),
+            ...(network === undefined ? {} : { network }),
+            systemPrompt,
+        }),
+    });
+}
+export function listArchetypeDefinitions(input) {
+    return archetypePaths(input.settings).map(({ name, path }) => {
+        try {
+            const definition = decodeArchetype(name, path, readFileSync(path, "utf8"));
+            return Object.freeze({
+                name: definition.name,
+                ...(definition.options.model === undefined ? {} : { model: definition.options.model }),
+                ...(definition.description === undefined ? {} : { description: definition.description }),
+            });
+        }
+        catch (error) {
+            throw new AkumaArchetypeError(name, [path], `is invalid: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : null;
+}
+function optionalProviderText(value, name, field) {
+    const selected = value[field];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new TypeError(`provider ${name} ${field} must be a nonblank string`);
+    }
+    return selected;
+}
+function configuredProvider(name, selected) {
+    const value = record(selected);
+    if (value === null)
+        throw new TypeError(`provider ${name} must be an object`);
+    const unknown = Object.keys(value).find((key) => !["kind", "description", "executable", "config", "env"].includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`provider ${name} has unknown field ${unknown}`);
+    optionalProviderText(value, name, "description");
+    return decodeProviderExecution({
+        name,
+        kind: value.kind,
+        ...(value.executable === undefined ? {} : { executable: value.executable }),
+        ...(value.config === undefined ? {} : { config: value.config }),
+        ...(value.env === undefined ? {} : { env: value.env }),
+    });
+}
+function providerExecution(settings, name) {
+    const view = settings.namespace("providers");
+    if (view.kind === "failed")
+        throw new TypeError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
+    const selected = view.entries.find((entry) => entry.name === name)?.value;
+    if (selected !== undefined)
+        return configuredProvider(name, selected);
+    if (name === "claude")
+        return Object.freeze({ name, kind: "claude-agent-sdk" });
+    if (name === "codex-app-server")
+        return Object.freeze({ name, kind: "codex-app-server" });
+    if (name === "opencode-sdk")
+        return Object.freeze({ name, kind: "opencode-sdk" });
+    if (name === "pi")
+        return Object.freeze({ name, kind: "pi" });
+    throw new TypeError(`unknown provider ${name}`);
+}
+function admitArchetype(archetype, settings) {
+    let execution;
+    try {
+        execution = providerExecution(settings, archetype.provider);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new AkumaArchetypeError(archetype.name, [archetype.path], `uses ${error.message}`);
+        throw error;
+    }
+    const adapter = providerNamed(execution);
+    const admission = adapter.admitOptions(archetype.options);
+    if (admission.kind === "refused") {
+        throw new AkumaArchetypeError(archetype.name, [archetype.path], `is unsupported: ${admission.diagnostic}`);
+    }
+    return Object.freeze({ ...archetype, provider: execution, adapter, options: admission.options });
+}
+export function loadArchetype(input) {
+    const name = archetypeName(input.name);
+    const directory = archetypeDirectory(input.settings);
+    if (directory === null)
+        throw new AkumaArchetypeError(name, [], "has no user Settings coordinate");
+    const path = join(directory, `${name}.md`);
+    let markdown;
+    try {
+        markdown = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new AkumaArchetypeError(name, [path], "was not found");
+        }
+        throw new AkumaArchetypeError(name, [path], `could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        return admitArchetype(decodeArchetype(name, path, markdown), input.settings);
+    }
+    catch (error) {
+        if (error instanceof AkumaArchetypeError)
+            throw error;
+        throw new AkumaArchetypeError(name, [path], `is invalid: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { type SessionFact, type Soul } from "./heart/index.js";
+import type { AkumaPaths } from "./identity.js";
+import { type ProviderAdapter } from "./provider.js";
+import { type RequestChildLaunch } from "./requests.js";
+import { type ProcessCollar } from "../runtime/proc/run.js";
+export type BodyLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed?: Omit<Soul, "createdAt">;
+    birthSession?: Omit<SessionFact, "sequence">;
+    initialBody?: string;
+}>;
+type BodyRuntime = Readonly<{
+    collar: ProcessCollar;
+    now(): string;
+    putDownOwnTree(collar: ProcessCollar): Promise<void>;
+    spawnChild?(launch: RequestChildLaunch): Promise<ProcessCollar>;
+}>;
+export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<void>;
+export declare function spawnAkumaBody(launch: BodyLaunch): Promise<ProcessCollar>;
+export {};