@frockbot/kernel-contracts 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/kernel-contracts",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "private": false,
   "type": "module",
   "exports": {

package/src/session.test.ts

@@ -368,6 +368,32 @@ describe("SessionStore", () => {
     ]);
   });
 
+  test("a failed durable write is reported and does not stop later writes", async () => {
+    const persisted: string[][] = [];
+    let failNext = true;
+    const root = await createStore(undefined, {
+      persistEvents: async (_sessionId, events) => {
+        await Promise.resolve();
+        if (failNext) {
+          failNext = false;
+          throw new Error("storage hiccup");
+        }
+        persisted.push(events.map((event) => event.type));
+      },
+    });
+    const session = root.sessions.create("durable-session");
+
+    // The Turn fails loudly rather than carrying on in memory over a log that
+    // silently stopped being written.
+    await expect(session.flush()).rejects.toThrow("storage hiccup");
+
+    // And the chain is not poisoned: chaining with `then` alone made every
+    // later write skip its callback for the life of the Session.
+    session.append({ type: "turn/start", turn: 1 });
+    await session.flush().catch(() => undefined);
+    expect(persisted).toEqual([["turn/start"]]);
+  });
+
   test("rehydrates a session and continues its sequence", async () => {
     const firstRoot = await createStore();
     const first = firstRoot.sessions.create("durable-session");

package/src/session.ts

@@ -210,6 +210,8 @@ export class Session {
   #emit: (envelope: SessionEventEnvelope) => void;
   #persist?: PersistSessionEvents;
   #pendingPersistence: Promise<void> = Promise.resolve();
+  /** The first durable write that failed. Every later `flush` reports it. */
+  #persistFailure: Error | undefined;
   /**
    * Resolved attachment bytes, keyed by content hash, held only while this
    * Session is resident.
@@ -273,15 +275,27 @@ export class Session {
     for (const event of events) this.#emit({ sessionId: this.id, event });
     if (this.#persist && events.length > 0) {
       const durableEvents = structuredClone(events);
-      this.#pendingPersistence = this.#pendingPersistence.then(() =>
-        this.#persist?.(this.id, durableEvents),
-      );
+      // A chain that has already rejected must still attempt this write.
+      // Chaining with `then` alone skipped the callback for the life of the
+      // Session — no event was ever written again while the loop carried on
+      // in memory — and left the rejection unhandled between an append and
+      // the next flush. The failure is remembered instead, and `flush` throws
+      // it, so the Turn fails loudly exactly once.
+      const pending = this.#pendingPersistence
+        .catch(() => undefined)
+        .then(() => this.#persist?.(this.id, durableEvents));
+      this.#pendingPersistence = pending;
+      void pending.catch((error: unknown) => {
+        this.#persistFailure ??=
+          error instanceof Error ? error : new Error(String(error));
+      });
     }
     return events;
   }
 
-  flush(): Promise<void> {
-    return this.#pendingPersistence;
+  async flush(): Promise<void> {
+    await this.#pendingPersistence.catch(() => undefined);
+    if (this.#persistFailure) throw this.#persistFailure;
   }
 
   /**

package/src/types.ts

@@ -1478,7 +1478,11 @@ export function decodeSessionEvent(input: unknown): SessionEvent {
         const label = `session event.refusals[${index}]`;
         const entry = eventRecord(refusal, label);
         requireEventKeys(entry, ["path", "reason"], label);
-        eventString(entry.path, `${label}.path`);
+        // A refusal that names no path is still a refusal — the read was
+        // declined at the root, and the reason is the part that matters.
+        // Rejecting it here killed the Turn *after* the event was appended,
+        // which left the durable log open inside that Turn and wedged the Bot.
+        eventString(entry.path, `${label}.path`, true);
         eventString(entry.reason, `${label}.reason`);
       });
       break;