@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,90 @@
+import type { AkuId, AkumaPaths } from "../identity.js";
+import type { BodyEnd, BodyFact, Collar, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
+export type { CallFact } from "./facts.js";
+import type { ActivityFact } from "./rows.js";
+import { type ActivityFactSlice } from "./timeline.js";
+export { HeldAkumaLeash, initializeHeart, probeLeash } from "./storage.js";
+export { life } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Collar, CollarProbe, Confinement, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, ProviderOptions, ProviderExecution, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export type { ResumeCoordinate } from "../coordinate.js";
+export declare function readSoul(paths: AkumaPaths): Soul | null;
+export declare function heartExists(paths: AkumaPaths): boolean;
+export declare function readSeal(paths: AkumaPaths): SealFact | null;
+export declare function recordBody(paths: AkumaPaths, input: Readonly<{
+    collar: Collar;
+    leashTakenAt: string;
+}>): BodyFact;
+export declare function recordSession(paths: AkumaPaths, input: Omit<SessionFact, "sequence">): SessionFact;
+export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
+    turnSequence: number;
+    event: unknown;
+    at: string;
+}>): number;
+export type ActivitySliceInput = Readonly<{
+    before?: number;
+    since?: number;
+    limit?: number;
+}>;
+export type ActivitySlice = ActivityFactSlice;
+export type { ActivityFact };
+export type { TimelineFact } from "./timeline.js";
+export declare function activitySlice(paths: AkumaPaths, input?: ActivitySliceInput): ActivitySlice;
+export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Readonly<{
+    kind: "not-born";
+} | {
+    kind: "recorded";
+    tell: TellFact;
+}>;
+export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): void;
+export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): void;
+export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
+    admittedAt: string;
+}>): RequestFact;
+export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
+export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
+export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): RequestFact;
+export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): RequestFact;
+export declare function readRequest(paths: AkumaPaths, id: string): RequestFact | null;
+export declare function readNonterminalRequests(paths: AkumaPaths): readonly RequestFact[];
+export declare function readKill(paths: AkumaPaths, bodySequence: number): KillFact | null;
+export declare function requestStop(paths: AkumaPaths, at: string): Readonly<{
+    kind: "requested";
+    body: BodyFact;
+}> | Readonly<{
+    kind: "already-killed";
+    body: BodyFact;
+}>;
+export declare function requestPause(paths: AkumaPaths, at: string): Readonly<{
+    kind: "not-born";
+} | {
+    kind: "requested";
+}>;
+export declare function stopRequested(paths: AkumaPaths, bodySequence?: number): boolean;
+export declare function pauseRequested(paths: AkumaPaths): boolean;
+export declare function breakBody(paths: AkumaPaths, input: Readonly<{
+    sequence: number;
+    end: Exclude<BodyEnd, "exited">;
+    at: string;
+}>): void;
+export declare function beginTurn(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    startedAt: string;
+    call?: string;
+}>): TurnStartFact;
+export declare function endTurn(paths: AkumaPaths, input: Readonly<{
+    turnSequence: number;
+    outcome: TurnOutcome;
+    completedAt: string;
+}>): TurnEndFact;
+export declare function finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
+    sequence: number;
+    at: string;
+}>): Readonly<{
+    kind: "finished";
+} | {
+    kind: "pending";
+    tells: readonly string[];
+}>;
+export declare function readHeart(paths: AkumaPaths): HeartSnapshot;
+export declare function readLastAnsweredTurn(paths: AkumaPaths): TurnFact | null;
+export declare function readForkPoint(paths: AkumaPaths, historyId: string): ForkPoint | null;

package/build/src/akuma/heart/index.js

@@ -0,0 +1,240 @@
+import { existsSync } from "node:fs";
+import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertBodyFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseExists, requestFact, sessionFactForCoordinate, soulFact, stopFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, } from "./rows.js";
+import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
+import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
+import { readSealFromLeash, transaction, withHeart } from "./storage.js";
+export { HeldAkumaLeash, initializeHeart, probeLeash } from "./storage.js";
+export { life } from "./facts.js";
+const ACTIVITY_LIMIT = 5_000;
+export function readSoul(paths) {
+    if (!existsSync(paths.heart))
+        return null;
+    return withHeart(paths, soulFact);
+}
+export function heartExists(paths) { return existsSync(paths.heart); }
+export function readSeal(paths) {
+    if (!existsSync(paths.leash))
+        return null;
+    return readSealFromLeash(paths);
+}
+export function recordBody(paths, input) {
+    return withHeart(paths, (heart) => {
+        return { sequence: insertBodyFact(heart, input), collar: input.collar, leashTakenAt: input.leashTakenAt };
+    });
+}
+export function recordSession(paths, input) {
+    return withHeart(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
+}
+export function appendActivity(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const sequence = insertActivityFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return sequence;
+    }));
+}
+export function activitySlice(paths, input = {}) {
+    const limit = input.limit ?? ACTIVITY_LIMIT;
+    return withHeart(paths, (heart) => activityFactSlice(heart, { ...input, limit }));
+}
+export function recordTell(paths, tell) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        if (soulFact(heart) === null)
+            return { kind: "not-born" };
+        const sequence = insertTellFact(heart, tell);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+    }));
+}
+export function recordTellDeliveries(paths, inputs) {
+    withHeart(paths, (heart) => transaction(heart, () => {
+        for (const input of inputs) {
+            const current = tellFact(heart, input.tellId);
+            if (current === null)
+                throw new Error(`unknown tell ${input.tellId}`);
+        }
+        for (const input of inputs)
+            insertTellDeliveryFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    }));
+}
+export function recordTellReceipt(paths, input) {
+    withHeart(paths, (heart) => transaction(heart, () => {
+        const tellIds = input.evidence === "exact"
+            ? [input.tellId]
+            : tellIdsForFence(heart, input.turnSequence, input.fence);
+        if (tellIds.length === 0)
+            throw new Error("tell receipt has no delivery mapping");
+        insertTellReceiptFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    }));
+}
+function sameRequestInput(fact, input) {
+    return fact.id === input.id
+        && fact.archetype === input.archetype
+        && fact.body === input.body
+        && fact.cwd === input.cwd
+        && fact.world === input.world
+        && JSON.stringify(fact.recipe) === JSON.stringify(input.recipe);
+}
+export function admitRequest(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        insertRequestFact(heart, input);
+        const fact = requestFact(heart, input.id);
+        if (fact === null)
+            throw new Error(`Akuma request ${input.id} was not admitted`);
+        if (!sameRequestInput(fact, input))
+            throw new Error(`Akuma request ${input.id} reused different input`);
+        return fact;
+    }));
+}
+export function reserveRequest(paths, id, child) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted")
+            updateRequestReserved(heart, id, child);
+        else if ((before.state !== "reserved" && before.state !== "served") || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot reserve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function serveRequest(paths, id, child) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "reserved" && before.child === child)
+            updateRequestServed(heart, id, child);
+        else if (before.state !== "served" || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot serve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function refuseRequest(paths, id, diagnostic) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted")
+            updateRequestRefused(heart, id, diagnostic);
+        else if (before.state !== "refused" || before.diagnostic !== diagnostic) {
+            throw new Error(`Akuma request ${id} cannot be refused`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function voidRequest(paths, id, evidence) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted" || before.state === "reserved")
+            updateRequestVoided(heart, id, evidence);
+        else if (before.state !== "voided" || before.evidence !== evidence) {
+            throw new Error(`Akuma request ${id} cannot be voided`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function readRequest(paths, id) {
+    return withHeart(paths, (heart) => requestFact(heart, id));
+}
+export function readNonterminalRequests(paths) {
+    return withHeart(paths, nonterminalRequestFacts);
+}
+export function readKill(paths, bodySequence) {
+    return withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
+}
+export function requestStop(paths, at) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const body = latestBodyFact(heart);
+        if (body === null)
+            throw new Error("Akuma has no Body to kill");
+        if (latestKillFact(heart)?.bodySequence === body.sequence)
+            return { kind: "already-killed", body };
+        const existing = stopFact(heart);
+        if (existing !== null && existing.bodySequence !== body.sequence) {
+            throw new Error("Akuma stop target is not the latest Body");
+        }
+        insertStopControl(heart, body.sequence, at);
+        return { kind: "requested", body };
+    }));
+}
+export function requestPause(paths, at) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        if (soulFact(heart) === null)
+            return { kind: "not-born" };
+        insertPauseControl(heart, at);
+        return { kind: "requested" };
+    }));
+}
+export function stopRequested(paths, bodySequence) {
+    return withHeart(paths, (heart) => {
+        const target = stopFact(heart);
+        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
+    });
+}
+export function pauseRequested(paths) { return withHeart(paths, pauseExists); }
+export function breakBody(paths, input) {
+    withHeart(paths, (heart) => endBodyFact(heart, input));
+}
+export function beginTurn(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const fact = insertTurnStartFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return fact;
+    }));
+}
+export function endTurn(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const fact = insertTurnEndFact(heart, { kind: "turn-end", ...input });
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return fact;
+    }));
+}
+export function finishBodyIfIdle(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const pending = pendingTellFacts(heart);
+        if (pending.length > 0)
+            return { kind: "pending", tells: pending.map((tell) => tell.id) };
+        finishBodyFact(heart, input);
+        return { kind: "finished" };
+    }));
+}
+export function readHeart(paths) {
+    if (!existsSync(paths.heart)) {
+        return { soul: null, latestBody: null, latestSession: null, pending: [], latestKill: null };
+    }
+    return withHeart(paths, (heart) => ({
+        soul: soulFact(heart),
+        latestBody: latestBodyFact(heart),
+        latestSession: latestSessionFact(heart),
+        pending: pendingTellFacts(heart),
+        latestKill: latestKillFact(heart),
+    }));
+}
+export function readLastAnsweredTurn(paths) {
+    return withHeart(paths, lastAnsweredTurnFact);
+}
+export function readForkPoint(paths, historyId) {
+    if (!existsSync(paths.heart))
+        return null;
+    return withHeart(paths, (heart) => {
+        const turn = answeredTurnFact(heart, historyId);
+        if (turn?.end?.outcome.kind !== "answered")
+            return null;
+        const recipe = sessionFactForCoordinate(heart, turn.end.outcome.session);
+        if (recipe === null)
+            throw new Error(`Akuma fork point ${historyId} has no session recipe`);
+        return {
+            historyId: turn.end.outcome.historyId,
+            session: turn.end.outcome.session,
+            provider: recipe.provider,
+            cwd: recipe.cwd,
+            options: recipe.options,
+        };
+    });
+}

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

@@ -0,0 +1,166 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { AkuId } from "../identity.js";
+import type { BodyEnd, BodyFact, CallFact, Collar, KillFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, Soul, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
+export type SoulRow = Readonly<{
+    id: string;
+    archetype: string;
+    description: string | null;
+    provider_json: string;
+    options_json: string;
+    cwd: string;
+    origin_json: string;
+    confinement_json: string;
+    created_at: string;
+}>;
+export type SealRow = Readonly<{
+    evidence: string;
+    at: string;
+}>;
+export type BodyRow = Readonly<{
+    sequence: number;
+    pid: number;
+    process_group: number;
+    spawned_at: string;
+    leash_taken_at: string;
+    end: BodyEnd | null;
+    ended_at: string | null;
+}>;
+export type SessionRow = Readonly<{
+    sequence: number;
+    provider: string;
+    coordinate_json: string;
+    cwd: string;
+    options_json: string;
+    admitted_at: string;
+}>;
+export type TurnRow = Readonly<{
+    sequence: number;
+    body_sequence: number;
+    started_at: string;
+    end_sequence: number | null;
+    outcome: "answered" | "failed" | null;
+    history_id: string | null;
+    session_json: string | null;
+    answer: string | null;
+    diagnostic: string | null;
+    completed_at: string | null;
+}>;
+export type CallRow = Readonly<{
+    sequence: number;
+    turn_sequence: number;
+    body: string;
+    at: string;
+}>;
+export type RequestRow = Readonly<{
+    sequence: number;
+    id: string;
+    archetype: string;
+    body: string;
+    cwd: string | null;
+    world: string;
+    recipe_json: string;
+    admitted_at: string;
+    state: RequestFact["state"];
+    child: string | null;
+    diagnostic: string | null;
+    evidence: string | null;
+}>;
+export type ActivityRow = Readonly<{
+    sequence: number;
+    turn_sequence: number;
+    event_json: string;
+    at: string;
+}>;
+export type ActivityFact = Readonly<{
+    kind: "activity";
+    sequence: number;
+    turnSequence: number;
+    event: unknown;
+    at: string;
+}>;
+export type KillRow = Readonly<{
+    sequence: number;
+    body_sequence: number;
+    evidence: "killed";
+    at: string;
+}>;
+export declare function encodeSoulRow(soul: Soul): readonly [
+    AkuId,
+    string,
+    string | null,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string
+];
+export declare function decodeSoulRow(row: SoulRow): Soul;
+export declare function encodeSessionRow(session: Omit<SessionFact, "sequence">): readonly [string, string, string, string, string];
+export declare function encodeResumeCoordinate(coordinate: ResumeCoordinate): string;
+export declare function decodeSessionRow(row: SessionRow): SessionFact;
+export declare function decodeBodyRow(row: BodyRow): BodyFact;
+export declare function decodeTurnRow(row: TurnRow): TurnFact;
+export declare function decodeCallRow(row: CallRow): CallFact;
+export declare function decodeRequestRow(row: RequestRow): RequestFact;
+export declare function encodeActivityEvent(event: unknown): string;
+export declare function decodeActivityRow(row: ActivityRow): ActivityFact;
+export declare function soulFact(database: DatabaseSync): Soul | null;
+export declare function sealExists(database: DatabaseSync): boolean;
+export declare function insertSoulFact(database: DatabaseSync, soul: Soul): void;
+export declare function insertSealFact(database: DatabaseSync, input: Readonly<{
+    evidence: string;
+    at: string;
+}>): void;
+export declare function deletePauseControl(database: DatabaseSync): void;
+export declare function deleteStopControl(database: DatabaseSync): void;
+export declare function sealFact(database: DatabaseSync): Readonly<{
+    evidence: string;
+    at: string;
+}> | null;
+export declare function insertBodyFact(database: DatabaseSync, input: Readonly<{
+    collar: Collar;
+    leashTakenAt: string;
+}>): number;
+export declare function insertSessionFact(database: DatabaseSync, input: Omit<SessionFact, "sequence">): number;
+export declare function insertActivityFact(database: DatabaseSync, input: Readonly<{
+    turnSequence: number;
+    event: unknown;
+    at: string;
+}>): number;
+export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
+    admittedAt: string;
+}>): void;
+export declare function requestFact(database: DatabaseSync, id: string): RequestFact | null;
+export declare function nonterminalRequestFacts(database: DatabaseSync): readonly RequestFact[];
+export declare function updateRequestReserved(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function updateRequestRefused(database: DatabaseSync, id: string, diagnostic: string): void;
+export declare function updateRequestVoided(database: DatabaseSync, id: string, evidence: string): void;
+export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;
+export declare function insertPauseControl(database: DatabaseSync, at: string): void;
+export declare function stopFact(database: DatabaseSync): StopFact | null;
+export declare function pauseExists(database: DatabaseSync): boolean;
+export declare function insertKillFact(database: DatabaseSync, bodySequence: number, at: string): void;
+export declare function endBodyFact(database: DatabaseSync, input: Readonly<{
+    sequence: number;
+    end: BodyEnd;
+    at: string;
+}>): void;
+export declare function insertTurnStartFact(database: DatabaseSync, input: Readonly<{
+    bodySequence: number;
+    startedAt: string;
+    call?: string;
+}>): TurnStartFact;
+export declare function insertTurnEndFact(database: DatabaseSync, input: Omit<TurnEndFact, "sequence">): TurnEndFact;
+export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{
+    sequence: number;
+    at: string;
+}>): void;
+export declare function latestBodyFact(database: DatabaseSync): BodyFact | null;
+export declare function latestSessionFact(database: DatabaseSync): SessionFact | null;
+export declare function sessionFactForCoordinate(database: DatabaseSync, coordinate: ResumeCoordinate): SessionFact | null;
+export declare function latestKillFact(database: DatabaseSync): KillFact | null;
+export declare function killFactForBody(database: DatabaseSync, bodySequence: number): KillFact | null;
+export declare function lastAnsweredTurnFact(database: DatabaseSync): TurnFact | null;
+export declare function answeredTurnFact(database: DatabaseSync, historyId: string): TurnFact | null;