@astrosheep/keiyaku 4.5.18 → 4.5.20

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

@@ -4,7 +4,7 @@ import { refuseRequest, reserveRequest } from "./heart/index.js";
 import { archetypeName, parseAkuId } from "./identity.js";
 import { publishAkuma } from "./publication.js";
 import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
-import { decodeProviderExecution } from "./providers/index.js";
+import { decodeProviderExecution, resolveProviderExecution } from "./providers/index.js";
 import { requestBodyCommand } from "./request-rendezvous.js";
 import { eraseRequestCommand, } from "./request-wire.js";
 import { z } from "zod";
@@ -67,6 +67,7 @@ const akumaCallPayloadSchema = z
     world: absolutePathSchema,
     archetype: archetypeSchema,
     body: z.string().optional(),
+    awaitAsleep: z.literal(true).optional(),
     cwd: absolutePathSchema.optional(),
     recipe: akumaCallRecipeSchema,
 })
@@ -86,17 +87,24 @@ async function executeAkumaCall(request, facts, capabilities) {
         await refuseRequest(paths, facts.id, `request world ${requestWorld} does not match ${world}`);
         throw new Error(`request world ${requestWorld} does not match ${world}`);
     }
+    const selected = await resolveProviderExecution(request.recipe.provider);
+    const admission = selected.adapter.admitOptions(request.recipe.options);
+    if (admission.kind === "refused") {
+        await refuseRequest(paths, facts.id, admission.diagnostic);
+        throw new Error(admission.diagnostic);
+    }
     const recipe = {
         ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
         allowed: clipAllowedActions(request.recipe.allowed, parent.allowed),
-        provider: request.recipe.provider,
-        options: request.recipe.options,
-        ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
+        provider: selected.execution,
+        options: admission.options,
+        ...(admission.readonly === undefined ? {} : { readonly: admission.readonly }),
     };
     const published = await publishAkuma({
         worldPath: world,
         archetype: request.archetype,
         signal: facts.signal,
+        ...(request.awaitAsleep === undefined ? {} : { awaitAsleep: request.awaitAsleep }),
         launch: async (allocated) => {
             if (!facts.admissionOpen())
                 throw new Error("body closed request admission");

package/build/src/akuma/fleet-execution.js

@@ -1,6 +1,6 @@
 import { AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 import { createAkumaProduct } from "./akuma-product.js";
-import { readBudgetedStatus } from "./akuma.js";
+import { readBudgetedStatus, readWaitComplete } from "./akuma-observe.js";
 import { NO_DISPATCH_ASSOCIATION } from "./dispatch-association.js";
 import { EMPTY_CREATED_TASK_OBSERVATION } from "../task/created-observation.js";
 import { fleetResultSchemas, parseAkumaObservation, } from "./fleet-observation.js";
@@ -45,6 +45,29 @@ async function observeWaitRound(path, ids, signal) {
     }
     return { statuses, unobserved };
 }
+async function probeWaitRound(input) {
+    let observed = 0;
+    let complete = 0;
+    for (const id of input.ids) {
+        input.signal?.throwIfAborted();
+        try {
+            if (await readWaitComplete(input.path, id))
+                complete += 1;
+            observed += 1;
+        }
+        catch (error) {
+            if (input.ids.length <= 1 || error instanceof AkumaNotBornError)
+                throw error;
+            // Plural wait retries unreadable members; final rendering owns diagnostics.
+        }
+    }
+    return observed > 0 && (input.completion === "any" ? complete > 0 : complete === input.ids.length);
+}
+function roundComplete(round, completion) {
+    const settled = round.statuses.map(defaultWaitComplete);
+    return (settled.length > 0 &&
+        (completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean)));
+}
 function delay(milliseconds, signal) {
     return new Promise((resolve, reject) => {
         let timer;
@@ -67,16 +90,17 @@ function delay(milliseconds, signal) {
 export async function executeWaitAkuma(input) {
     const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
     for (;;) {
-        const round = await observeWaitRound(input.path, input.ids, input.signal);
-        const settled = round.statuses.map(defaultWaitComplete);
-        const completed = round.statuses.length > 0 &&
-            (input.completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean));
-        if (completed || (deadline !== undefined && performance.now() >= deadline)) {
-            return fleetResultSchemas.wait.parse({
-                completion: input.completion,
-                observations: round.statuses.map(akumaOnlyObservation),
-                unobserved: round.unobserved,
-            });
+        if ((deadline !== undefined && performance.now() >= deadline) || (await probeWaitRound(input))) {
+            const round = await observeWaitRound(input.path, input.ids, input.signal);
+            input.signal?.throwIfAborted();
+            // The probe is not a completion receipt. Judge the actual returned values.
+            if (roundComplete(round, input.completion) || (deadline !== undefined && performance.now() >= deadline)) {
+                return fleetResultSchemas.wait.parse({
+                    completion: input.completion,
+                    observations: round.statuses.map(akumaOnlyObservation),
+                    unobserved: round.unobserved,
+                });
+            }
         }
         await delay(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
     }

package/build/src/akuma/fleet-observation.d.ts

@@ -10,6 +10,24 @@ declare const akumaObservationSchema: z.ZodObject<{
             asleep: "asleep";
             stranded: "stranded";
         }>;
+        allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+            "task.add": "task.add";
+            "task.addDocument": "task.addDocument";
+            "task.compose": "task.compose";
+            "task.done": "task.done";
+            "task.drop": "task.drop";
+            "task.hold": "task.hold";
+            "task.resume": "task.resume";
+            "task.start": "task.start";
+            "task.stop": "task.stop";
+            "task.update": "task.update";
+            "akuma.call": "akuma.call";
+            "akuma.kill": "akuma.kill";
+            "akuma.tell": "akuma.tell";
+            "contract.audit": "contract.audit";
+            "contract.deliver": "contract.deliver";
+            "contract.review": "contract.review";
+        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
         readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             enforcement: z.ZodLiteral<"native">;
         }, z.core.$strict>, z.ZodObject<{
@@ -446,6 +464,24 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                 asleep: "asleep";
                 stranded: "stranded";
             }>;
+            allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+                "task.add": "task.add";
+                "task.addDocument": "task.addDocument";
+                "task.compose": "task.compose";
+                "task.done": "task.done";
+                "task.drop": "task.drop";
+                "task.hold": "task.hold";
+                "task.resume": "task.resume";
+                "task.start": "task.start";
+                "task.stop": "task.stop";
+                "task.update": "task.update";
+                "akuma.call": "akuma.call";
+                "akuma.kill": "akuma.kill";
+                "akuma.tell": "akuma.tell";
+                "contract.audit": "contract.audit";
+                "contract.deliver": "contract.deliver";
+                "contract.review": "contract.review";
+            }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
             readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                 enforcement: z.ZodLiteral<"native">;
             }, z.core.$strict>, z.ZodObject<{
@@ -1001,6 +1037,24 @@ export declare const fleetResultSchemas: {
                     asleep: "asleep";
                     stranded: "stranded";
                 }>;
+                allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+                    "task.add": "task.add";
+                    "task.addDocument": "task.addDocument";
+                    "task.compose": "task.compose";
+                    "task.done": "task.done";
+                    "task.drop": "task.drop";
+                    "task.hold": "task.hold";
+                    "task.resume": "task.resume";
+                    "task.start": "task.start";
+                    "task.stop": "task.stop";
+                    "task.update": "task.update";
+                    "akuma.call": "akuma.call";
+                    "akuma.kill": "akuma.kill";
+                    "akuma.tell": "akuma.tell";
+                    "contract.audit": "contract.audit";
+                    "contract.deliver": "contract.deliver";
+                    "contract.review": "contract.review";
+                }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
                 readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                     enforcement: z.ZodLiteral<"native">;
                 }, z.core.$strict>, z.ZodObject<{

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

@@ -100,7 +100,8 @@ export function fleetRequestProtocol(action) {
         decodeResult: (result) => decodedFleetResult(action, result),
         decodeReference: (reference) => decodeFleetService(action, reference),
         isPermitted: (allowed) => action === "akuma.wait" ||
-            ((action === "akuma.tell" || action === "akuma.tell-answer") && allowed.includes("akuma.tell")),
+            ((action === "akuma.tell" || action === "akuma.tell-answer") && allowed.includes("akuma.tell")) ||
+            (action === "akuma.kill" && allowed.includes("akuma.kill")),
     };
 }
 export function fleetRequestCommand(action, port) {

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

@@ -2,7 +2,7 @@ import type { AkumaPaths } from "../identity.js";
 import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, 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";
+import { type StatusFactInput, type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
 export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
@@ -22,6 +22,12 @@ export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
 export type { TimelineFact } from "./timeline.js";
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
+export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput): Promise<ActivitySlice["rows"]>;
+type LifeSnapshot = Pick<HeartSnapshot, "soul" | "latestBody" | "latestSession" | "latestKill"> & Readonly<{
+    hasPendingTell: boolean;
+}>;
+/** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
+export declare function readLifeSnapshot(paths: AkumaPaths): Promise<LifeSnapshot>;
 export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">, options?: Readonly<{
     interrupt?: boolean;
 }>): Promise<Readonly<{
@@ -43,29 +49,17 @@ export declare function decidePendingTellDisposition(paths: AkumaPaths, input: R
     handoff: boolean;
 }>): Promise<PendingTellDisposition | null>;
 export declare function readOpenPendingTellDisposition(paths: AkumaPaths): Promise<PendingTellDisposition | null>;
-export declare function resolvePendingTellDisposition(paths: AkumaPaths, bodySequence: number, at: string): Promise<void>;
-/**
- * Heart-owned disposition custody proof. Sequence growth, spawn resolution, and
- * an unqualified held leash are never proof. Returns the successor Body sequence
- * when that exact Body took the frozen Tell-id snapshot by delivery, or true when
- * the snapshot is already fully settled (no longer pending).
- */
-export declare function provePendingTellDispositionCustody(paths: AkumaPaths, disposition: PendingTellDisposition): Promise<Readonly<{
-    kind: "proven";
-    successorBodySequence?: number;
-} | {
-    kind: "unproven";
-}>>;
-export declare function recordUndeliveredPendingTells(paths: AkumaPaths, at: string, tellIds: readonly string[]): Promise<void>;
+/** Prove and consume the persisted decision in one transaction, never a caller's stale member list. */
+export declare function resolvePendingTellDisposition(paths: AkumaPaths, bodySequence: number, at: string, outcome?: "custody" | "undelivered"): Promise<boolean>;
 export declare function readKill(paths: AkumaPaths, bodySequence: number): Promise<KillFact | null>;
-export declare function requestStop(paths: AkumaPaths, at: string): Promise<Readonly<{
+export declare function requestStop(paths: AkumaPaths, at: string, signal?: AbortSignal): Promise<Readonly<{
     kind: "requested";
     body: BodyFact;
 }> | Readonly<{
     kind: "already-killed" | "already-stopped";
     body: BodyFact;
 }>>;
-export declare function requestPause(paths: AkumaPaths, at: string): Promise<Readonly<{
+export declare function requestPause(paths: AkumaPaths, at: string, signal?: AbortSignal): Promise<Readonly<{
     kind: "not-born";
 } | {
     kind: "requested";

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

@@ -1,10 +1,10 @@
 import { parsePublicHistoryId } from "../identity.js";
 import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
-import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, resolveTellDispositionSnapshot, successorBodyHoldingDisposition, tellFact, tellIdsForFence, } from "./tells.js";
-import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
-import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart, withReadOnlyHeart, } from "./storage.js";
+import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, } from "./tells.js";
+import { activityFactSlice, statusFacts, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
+import { isHeartAbsent, readSealFromLeash, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-import { AkumaBusyError } from "./facts.js";
+import { AkumaBusyError, HeartAuthorityCorruptionError } from "./facts.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
 export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
@@ -12,7 +12,7 @@ export { drainPendingTells } from "./tells.js";
 const ACTIVITY_LIMIT = 5_000;
 export async function readSoul(paths) {
     try {
-        return await withHeart(paths, soulFact);
+        return await withReadOnlyHeart(paths, soulFact);
     }
     catch (error) {
         if (isHeartAbsent(error))
@@ -22,7 +22,7 @@ export async function readSoul(paths) {
 }
 export async function heartExists(paths) {
     try {
-        return await withHeart(paths, () => true);
+        return await withReadOnlyHeart(paths, () => true);
     }
     catch (error) {
         if (isHeartAbsent(error))
@@ -41,23 +41,43 @@ export async function readSeal(paths) {
     }
 }
 export async function recordSession(paths, input) {
-    return await withHeart(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
+    return await withHeartTransaction(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
 }
 export async function appendActivity(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const sequence = insertActivityFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return sequence;
-    }));
+    });
 }
 export async function activitySlice(paths) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => activityFactSlice(heart)));
+    return await withReadOnlyHeart(paths, (heart) => activityFactSlice(heart));
+}
+export async function readStatusFacts(paths, input) {
+    return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input));
+}
+/** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
+export async function readLifeSnapshot(paths) {
+    try {
+        return await withReadOnlyHeart(paths, (heart) => ({
+            soul: soulFact(heart),
+            latestBody: latestBodyFact(heart),
+            latestSession: latestSessionFact(heart),
+            latestKill: latestKillFact(heart),
+            hasPendingTell: hasPendingTell(heart),
+        }));
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return { soul: null, latestBody: null, latestSession: null, latestKill: null, hasPendingTell: false };
+        throw error;
+    }
 }
 function sameTellInput(existing, tell) {
     return (existing.body === tell.body && existing.recordedAt === tell.recordedAt && existing.schemaJson === tell.schemaJson);
 }
 export async function recordTell(paths, tell, options = {}) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
         const existing = tellFact(heart, tell.id);
@@ -73,37 +93,40 @@ export async function recordTell(paths, tell, options = {}) {
         const sequence = insertTellFact(heart, tell);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
-    }));
+    });
 }
 export async function readTell(paths, id) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => tellFact(heart, id)));
+    return await withReadOnlyHeart(paths, (heart) => tellFact(heart, id));
 }
 export async function recordTellDeliveries(paths, inputs) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    await withHeartTransaction(paths, (heart) => {
         for (const input of inputs) {
             const current = tellFact(heart, input.tellId);
             if (current === null)
                 throw new Error(`unknown tell ${input.tellId}`);
         }
+        let changed = false;
         for (const input of inputs)
-            insertTellDeliveryFact(heart, input);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
+            changed = insertTellDeliveryFact(heart, input) || changed;
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, changed);
+    });
 }
 export async function recordTellReceipt(paths, input) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    await withHeartTransaction(paths, (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);
-    }));
+        const changed = insertTellReceiptFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, changed);
+    });
 }
 export async function decidePendingTellDisposition(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const body = latestBodyFact(heart);
         if (body === null || body.sequence !== input.bodySequence)
             return null;
+        if (tellDispositionResolved(heart, input.bodySequence) === true)
+            return null;
         const existing = openTellDispositionIds(heart, input.bodySequence);
         if (existing !== null)
             return { bodySequence: input.bodySequence, tellIds: existing };
@@ -122,46 +145,33 @@ export async function decidePendingTellDisposition(paths, input) {
         insertTellDispositionSnapshot(heart, input.bodySequence, tellIds, input.at);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return { bodySequence: input.bodySequence, tellIds };
-    }));
+    });
 }
 export async function readOpenPendingTellDisposition(paths) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => latestOpenTellDisposition(heart)));
-}
-export async function resolvePendingTellDisposition(paths, bodySequence, at) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withReadOnlyHeart(paths, (heart) => latestOpenTellDisposition(heart));
+}
+/** Prove and consume the persisted decision in one transaction, never a caller's stale member list. */
+export async function resolvePendingTellDisposition(paths, bodySequence, at, outcome = "custody") {
+    return await withHeartTransaction(paths, (heart) => {
+        if (tellDispositionResolved(heart, bodySequence) === true)
+            return true;
+        const tellIds = openTellDispositionIds(heart, bodySequence);
+        if (tellIds === null)
+            throw new HeartAuthorityCorruptionError(`Akuma disposition ${bodySequence} is missing`);
+        if (outcome === "undelivered")
+            insertUndeliveredTellReceipts(heart, tellIds, at);
+        if (!dispositionSnapshotProven(heart, tellIds))
+            return false;
         resolveTellDispositionSnapshot(heart, bodySequence, at);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
-}
-/**
- * Heart-owned disposition custody proof. Sequence growth, spawn resolution, and
- * an unqualified held leash are never proof. Returns the successor Body sequence
- * when that exact Body took the frozen Tell-id snapshot by delivery, or true when
- * the snapshot is already fully settled (no longer pending).
- */
-export async function provePendingTellDispositionCustody(paths, disposition) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => {
-        if (!dispositionSnapshotProven(heart, disposition))
-            return { kind: "unproven" };
-        const successorBodySequence = successorBodyHoldingDisposition(heart, disposition);
-        return successorBodySequence === null
-            ? { kind: "proven" }
-            : { kind: "proven", successorBodySequence };
-    }));
-}
-export async function recordUndeliveredPendingTells(paths, at, tellIds) {
-    if (tellIds.length === 0)
-        return;
-    await withHeart(paths, (heart) => transaction(heart, () => {
-        insertUndeliveredTellReceipts(heart, tellIds, at);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, true);
+        return true;
+    });
 }
 export async function readKill(paths, bodySequence) {
-    return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
+    return await withReadOnlyHeart(paths, (heart) => killFactForBody(heart, bodySequence));
 }
-export async function requestStop(paths, at) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+export async function requestStop(paths, at, signal) {
+    return await withHeartTransaction(paths, (heart) => {
         const body = latestBodyFact(heart);
         if (body === null)
             throw new Error("Akuma has no Body to kill");
@@ -175,10 +185,10 @@ export async function requestStop(paths, at) {
         }
         insertStopControl(heart, body.sequence, at);
         return { kind: "requested", body };
-    }));
+    }, signal);
 }
-export async function requestPause(paths, at) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+export async function requestPause(paths, at, signal) {
+    return await withHeartTransaction(paths, (heart) => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
         const body = latestBodyFact(heart);
@@ -186,45 +196,45 @@ export async function requestPause(paths, at) {
             throw new Error("Akuma has no Body to interrupt");
         insertPauseControl(heart, at);
         return { kind: "requested", body };
-    }));
+    }, signal);
 }
 export async function stopRequested(paths, bodySequence) {
-    return await withHeart(paths, (heart) => {
+    return await withReadOnlyHeart(paths, (heart) => {
         const target = stopFact(heart);
         return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
     });
 }
 export async function pauseRequested(paths, bodySequence) {
-    return await withHeart(paths, (heart) => {
+    return await withReadOnlyHeart(paths, (heart) => {
         const target = pauseFact(heart);
         return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
     });
 }
 export async function breakBody(paths, input) {
-    await withHeart(paths, (heart) => endBodyFact(heart, input));
+    await withHeartTransaction(paths, (heart) => endBodyFact(heart, input));
 }
 export async function beginTurn(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const fact = insertTurnStartFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return fact;
-    }));
+    });
 }
 export async function bindTellsToTurn(paths, input) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    await withHeartTransaction(paths, (heart) => {
         for (const tellId of input.tellIds) {
             if (tellFact(heart, tellId) === null)
                 throw new Error(`unknown tell ${tellId}`);
             insertTellBindingFact(heart, { tellId, turnSequence: input.turnSequence, boundAt: input.boundAt });
         }
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
+    });
 }
 export async function readOpenBoundTurns(paths, bodySequence) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => openBoundTurns(heart, bodySequence)));
+    return await withReadOnlyHeart(paths, (heart) => openBoundTurns(heart, bodySequence));
 }
 export async function failOpenBoundTurns(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const sequences = openBoundTurns(heart, input.bodySequence);
         for (const turnSequence of sequences) {
             insertTurnEndFact(heart, {
@@ -234,22 +244,22 @@ export async function failOpenBoundTurns(paths, input) {
                 completedAt: input.completedAt,
             });
         }
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, sequences.length > 0);
         return sequences;
-    }));
+    });
 }
 export async function readTurn(paths, sequence) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => turnFact(heart, sequence)));
+    return await withReadOnlyHeart(paths, (heart) => turnFact(heart, sequence));
 }
 export async function endTurn(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const fact = insertTurnEndFact(heart, { kind: "turn-end", ...input });
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, true);
         return fact;
-    }));
+    });
 }
 export async function finishBodyIfIdle(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         if (stopFact(heart)?.bodySequence === input.sequence || pauseFact(heart)?.bodySequence === input.sequence) {
             endBodyFact(heart, { ...input, end: "put-down" });
             return { kind: "controlled" };
@@ -259,11 +269,11 @@ export async function finishBodyIfIdle(paths, input) {
             return { kind: "pending", tells: pending.map((tell) => tell.id) };
         finishBodyFact(heart, input);
         return { kind: "finished" };
-    }));
+    });
 }
 export async function readHeart(paths) {
     try {
-        return await withReadOnlyHeart(paths, (heart) => readTransaction(heart, () => ({
+        return await withReadOnlyHeart(paths, (heart) => ({
             soul: soulFact(heart),
             latestBody: latestBodyFact(heart),
             latestSession: latestSessionFact(heart),
@@ -272,7 +282,7 @@ export async function readHeart(paths) {
             stop: stopFact(heart),
             pause: pauseFact(heart),
             lastActivityAt: readLastActivityAt(heart),
-        })));
+        }));
     }
     catch (error) {
         if (isHeartAbsent(error)) {
@@ -291,14 +301,14 @@ export async function readHeart(paths) {
     }
 }
 export async function readLastAnsweredTurn(paths) {
-    return await withHeart(paths, lastAnsweredTurnFact);
+    return await withReadOnlyHeart(paths, lastAnsweredTurnFact);
 }
 export async function readForkPoint(paths, historyId) {
     const turnSequence = parsePublicHistoryId(historyId);
     if (turnSequence === null)
         return null;
     try {
-        return await withHeart(paths, (heart) => {
+        return await withReadOnlyHeart(paths, (heart) => {
             const turn = answeredTurnFact(heart, turnSequence);
             const outcome = turn?.end?.outcome;
             if (outcome?.kind !== "answered" || outcome.historyId === undefined)