@remnic/core 10.0.36 → 10.0.38

package/dist/who-knows.js

@@ -9,37 +9,37 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-BRZRP5WD.js";
-import "./chunk-O3VKQMWC.js";
-import "./chunk-DM5QZ3YU.js";
+} from "./chunk-VSSQIBVU.js";
+import "./chunk-WCBLPKG3.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
-import "./chunk-TKBW4YLS.js";
-import "./chunk-23VGZ65V.js";
-import "./chunk-UR25IQVT.js";
+import "./chunk-JH4FCVWJ.js";
+import "./chunk-LHBOFROT.js";
+import "./chunk-P5CUEB2Q.js";
+import "./chunk-XRFLR3XF.js";
 import "./chunk-7VO6E5UD.js";
 import "./chunk-EXYT52NR.js";
-import "./chunk-2ZYIAUYU.js";
-import "./chunk-C6S2Y7HE.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-B6L7BKA7.js";
-import "./chunk-Y5NLBXPV.js";
+import "./chunk-5CWH2LKL.js";
+import "./chunk-XKDQTDXN.js";
 import "./chunk-WNEVEMJ3.js";
-import "./chunk-QCP75JGO.js";
-import "./chunk-A7Q43EUZ.js";
+import "./chunk-Y5NLBXPV.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
+import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-PPUNC7UX.js";
 import "./chunk-X3724WL4.js";
-import "./chunk-S2HLHAZ4.js";
 import "./chunk-MRPOZBJC.js";
+import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FF6N7BXC.js";
-import "./chunk-5EILJ6W2.js";
+import "./chunk-WXPBDEMW.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-YOL56HY5.js";
+import "./chunk-YQ6SLFNZ.js";
 import "./chunk-ZIKENA2C.js";
 import "./chunk-YXZG5TVN.js";
 import "./chunk-3OUGSOJP.js";
@@ -55,45 +55,45 @@ import "./chunk-LWRIGKFM.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-7CT3AI52.js";
-import "./chunk-GMMZ45C4.js";
-import "./chunk-I55KAVET.js";
-import "./chunk-L2EXJQJP.js";
-import "./chunk-45GF7Y3V.js";
-import "./chunk-YIJECSIX.js";
-import "./chunk-E2AWJ7KQ.js";
-import "./chunk-UUZ7KZAO.js";
-import "./chunk-V44DWTFA.js";
+import "./chunk-AYXRK264.js";
+import "./chunk-IUM3VSHI.js";
 import "./chunk-G26YNEOC.js";
 import "./chunk-VILPVT4S.js";
 import "./chunk-AF2XMJKD.js";
 import "./chunk-OR42ZI54.js";
-import "./chunk-IUM3VSHI.js";
+import "./chunk-23G5P7TA.js";
 import "./chunk-C64XATK7.js";
 import "./chunk-42JKGUFJ.js";
-import "./chunk-23G5P7TA.js";
+import "./chunk-AVVCPA7U.js";
+import "./chunk-I55KAVET.js";
+import "./chunk-L2EXJQJP.js";
+import "./chunk-45GF7Y3V.js";
+import "./chunk-YIJECSIX.js";
+import "./chunk-E2AWJ7KQ.js";
+import "./chunk-UUZ7KZAO.js";
 import "./chunk-HADD45AR.js";
 import "./chunk-RNFMFC37.js";
 import "./chunk-YCVB7X56.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-PJKTFXE2.js";
 import "./chunk-W5BIQOAJ.js";
-import "./chunk-A6PKEU7T.js";
+import "./chunk-UFM3PJDT.js";
 import "./chunk-YBA52OKG.js";
-import "./chunk-3ODEGTVV.js";
+import "./chunk-TDCR6PQL.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-PTQZPVRQ.js";
+import "./chunk-E5PVMB3I.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
 import "./chunk-L272A5QW.js";
-import "./chunk-JNELS2TW.js";
+import "./chunk-UJDTXWMT.js";
 import "./chunk-ZA53AZND.js";
 import "./chunk-7RJUVTVF.js";
 import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
 import "./chunk-YET735EZ.js";
 import "./chunk-PWPIERBM.js";
-import "./chunk-IS4HKNWP.js";
+import "./chunk-UBN5AOLT.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-BTNNL7ZW.js";
 import "./chunk-JDSVLVCG.js";
@@ -111,7 +111,7 @@ import "./chunk-3MUKQQ7A.js";
 import "./chunk-R2MBW2S4.js";
 import "./chunk-QUIRIG2P.js";
 import "./chunk-LDPPTPO5.js";
-import "./chunk-ZG3HZZ6K.js";
+import "./chunk-TYGLV6ZG.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-C7HJ3NEI.js";
 import "./chunk-VS2IYZRU.js";

package/dist/write-envelope.js

@@ -12,10 +12,10 @@ import {
   isMemoryCategory,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-3ODEGTVV.js";
+} from "./chunk-TDCR6PQL.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-PTQZPVRQ.js";
-import "./chunk-IS4HKNWP.js";
+import "./chunk-E5PVMB3I.js";
+import "./chunk-UBN5AOLT.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
@@ -24,7 +24,7 @@ import "./chunk-EBRG7ZIK.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-X4OZMANG.js";
 import "./chunk-R2MBW2S4.js";
-import "./chunk-ZG3HZZ6K.js";
+import "./chunk-TYGLV6ZG.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-C7HJ3NEI.js";
 import "./chunk-VS2IYZRU.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.36",
+  "version": "10.0.38",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3347,7 +3347,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^10.0.36"
+    "@remnic/coding-graph": "^10.0.38"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/buffer-eviction.ts

@@ -0,0 +1,51 @@
+import type { BufferEntryState } from "./types.js";
+
+const EMPTY_ENTRY: BufferEntryState = { turns: [], lastExtractionAt: null, extractionCount: 0 };
+
+export interface BufferEvictionHooks {
+  /** Last activity time (ms) of an entry; older entries are evicted first. */
+  activityAt(entry: BufferEntryState): number;
+  /** Accepted captures exit via refusal/backpressure, never eviction (#3251). */
+  holdsAcceptedCapture(entry: BufferEntryState | undefined): boolean;
+}
+
+/**
+ * Pick the keys to evict so `entries` returns to `maxCount`: the oldest empty
+ * sessions first; retained failed extractions (#1908) keep their turns, so if
+ * empty entries alone cannot reach the cap the oldest NON-empty sessions go
+ * too rather than growing unboundedly. "default", the retained keys and
+ * entries holding an accepted capture are never chosen.
+ */
+export function selectEvictedBufferKeys(
+  entries: Readonly<Record<string, BufferEntryState>>,
+  retainKeys: readonly string[],
+  maxCount: number,
+  hooks: BufferEvictionHooks,
+): string[] {
+  const keys = Object.keys(entries);
+  if (keys.length <= maxCount) return [];
+
+  const insertionOrder = new Map(keys.map((key, index) => [key, index]));
+  const byOldestActivity = (left: string, right: string): number => {
+    const leftAt = hooks.activityAt(entries[left] ?? EMPTY_ENTRY);
+    const rightAt = hooks.activityAt(entries[right] ?? EMPTY_ENTRY);
+    if (leftAt !== rightAt) return leftAt - rightAt;
+    return (insertionOrder.get(left) ?? 0) - (insertionOrder.get(right) ?? 0);
+  };
+  const candidates = keys.filter(
+    (key) => key !== "default" && !retainKeys.includes(key) && !hooks.holdsAcceptedCapture(entries[key]),
+  );
+  const emptyRemovable = candidates
+    .filter((key) => (entries[key]?.turns.length ?? 0) === 0)
+    .sort(byOldestActivity);
+
+  const removableCount = Math.max(0, keys.length - maxCount);
+  const evicted = emptyRemovable.slice(0, removableCount);
+  if (evicted.length < removableCount) {
+    const nonEmptyRemovable = candidates
+      .filter((key) => (entries[key]?.turns.length ?? 0) > 0)
+      .sort(byOldestActivity);
+    return evicted.concat(nonEmptyRemovable.slice(0, removableCount - evicted.length));
+  }
+  return evicted;
+}

package/src/buffer-incremental-persistence.test.ts

@@ -0,0 +1,256 @@
+/**
+ * Per-session incremental buffer persistence (SmartBuffer layer).
+ *
+ * Pins the hot-path contract on top of the storage primitives tested in
+ * storage-buffer-sessions.test.ts:
+ *
+ *   - a storage that exposes saveBufferSession/deleteBufferSession gets
+ *     INCREMENTAL saves: only the sessions whose state actually changed are
+ *     written, only on boundaries that need durability;
+ *   - sessions whose state did not change are never rewritten;
+ *   - eviction and resetToEmpty delete the corresponding session files;
+ *   - a legacy storage (only loadBuffer/saveBuffer) keeps the exact old
+ *     whole-state behavior — existing deployments and test doubles are
+ *     unaffected.
+ *
+ * All saves flow through SmartBuffer's mutation chain, so there is exactly
+ * one writer per session file.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { SmartBuffer } from "./buffer.js";
+import { parseConfig } from "./config.js";
+import { StorageManager } from "./storage.js";
+import type { BufferEntryState, BufferState, BufferTurn } from "./types.js";
+
+interface SessionFileRecord {
+  entry: BufferEntryState;
+  writeCount: number;
+}
+
+/**
+ * Storage double implementing the incremental per-session surface. Records
+ * per-session writes/deletes and whole-state saves separately so tests can
+ * assert exactly which files the hot path touched.
+ */
+class IncrementalStorage {
+  readonly sessions = new Map<string, SessionFileRecord>();
+  readonly deleted: string[] = [];
+  wholeStateSaves = 0;
+  private initial: BufferState;
+
+  constructor(initial: BufferState) {
+    this.initial = initial;
+  }
+
+  async loadBuffer(): Promise<BufferState> {
+    return structuredClone(this.initial);
+  }
+
+  async saveBuffer(state: BufferState): Promise<void> {
+    this.wholeStateSaves += 1;
+    this.initial = structuredClone(state);
+  }
+
+  async saveBufferSession(key: string, entry: BufferEntryState): Promise<void> {
+    const record = this.sessions.get(key) ?? { entry, writeCount: 0 };
+    record.entry = structuredClone(entry);
+    record.writeCount += 1;
+    this.sessions.set(key, record);
+  }
+
+  async deleteBufferSession(key: string): Promise<void> {
+    this.deleted.push(key);
+    this.sessions.delete(key);
+  }
+}
+
+/**
+ * Storage double implementing ONLY the legacy whole-state surface — every
+ * pre-existing test double in the repo looks like this from SmartBuffer's
+ * point of view, and must keep working unchanged.
+ */
+class LegacyOnlyStorage {
+  wholeStateSaves = 0;
+  lastSaved: BufferState | null = null;
+
+  constructor(private initial: BufferState) {}
+
+  async loadBuffer(): Promise<BufferState> {
+    return structuredClone(this.initial);
+  }
+
+  async saveBuffer(state: BufferState): Promise<void> {
+    this.wholeStateSaves += 1;
+    this.lastSaved = structuredClone(state);
+  }
+}
+
+function makeTurn(sessionKey: string, content: string): BufferTurn {
+  return {
+    role: "user",
+    content,
+    timestamp: "2026-10-29T12:00:00.000Z",
+    sessionKey,
+  };
+}
+
+function emptyState(): BufferState {
+  return { turns: [], lastExtractionAt: null, extractionCount: 0 };
+}
+
+test("steady-state observe persists only the active session's file", async () => {
+  const storage = new IncrementalStorage(emptyState());
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 }), storage);
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "alpha"));
+  await buffer.flushPendingSave();
+  assert.equal(storage.wholeStateSaves, 0, "hot path fell back to whole-state save");
+  assert.equal(storage.sessions.get("thread-a")?.writeCount, 1);
+  assert.equal(storage.sessions.get("thread-a")?.entry.turns[0]?.content, "alpha");
+
+  await buffer.addTurn("thread-b", makeTurn("thread-b", "beta"));
+  await buffer.flushPendingSave();
+  assert.equal(storage.sessions.get("thread-b")?.writeCount, 1);
+  // Session A's turn did NOT touch session A's file again.
+  assert.equal(storage.sessions.get("thread-a")?.writeCount, 1, "unchanged session file was rewritten");
+});
+
+test("a second turn in the same session rewrites only that session's file", async () => {
+  const storage = new IncrementalStorage(emptyState());
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 }), storage);
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "one"));
+  await buffer.flushPendingSave();
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "two"));
+  await buffer.flushPendingSave();
+
+  const record = storage.sessions.get("thread-a");
+  assert.equal(record?.writeCount, 2);
+  assert.equal(record?.entry.turns.length, 2);
+});
+
+test("extraction-boundary turn persists inline and durably", async () => {
+  const storage = new IncrementalStorage(emptyState());
+  // bufferMaxTurns: 1 → the very first turn triggers extract_batch.
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 1 }), storage);
+
+  const outcome = await buffer.addTurnWithOutcome("thread-a", makeTurn("thread-a", "trigger"));
+  assert.equal(outcome.decision, "extract_batch");
+  // Inline save already ran inside the mutation — no flush needed.
+  assert.equal(storage.sessions.get("thread-a")?.writeCount, 1);
+  assert.equal(storage.wholeStateSaves, 0, "extraction boundary fell back to whole-state save");
+});
+
+test("clearAfterExtraction persists the cleared session state", async () => {
+  const storage = new IncrementalStorage(emptyState());
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 }), storage);
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "alpha"));
+  await buffer.flushPendingSave();
+  const before = storage.sessions.get("thread-a")?.writeCount ?? 0;
+
+  await buffer.clearAfterExtraction("thread-a");
+  const record = storage.sessions.get("thread-a");
+  assert.equal(record?.writeCount, before + 1, "clearAfterExtraction did not persist the session");
+  assert.equal(record?.entry.turns.length, 0);
+  assert.equal(record?.entry.extractionCount, 1);
+});
+
+test("evicted sessions get their files deleted", async () => {
+  const storage = new IncrementalStorage(emptyState());
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 }), storage);
+
+  // normalizeState always materializes a "default" entry, so 198 seeded
+  // sessions + default = 199; new-session reaches exactly 200 (the
+  // addTurnBounded cap). One more UNBOUNDED addTurn pushes to 201 and
+  // pruneEntries evicts the oldest non-default session (s0).
+  for (let i = 0; i < 198; i++) {
+    const key = `s${i}`;
+    await buffer.addTurnBounded(key, makeTurn(key, `content ${i}`));
+  }
+  await buffer.flushPendingSave();
+
+  const outcome = await buffer.addTurnBounded("new-session", makeTurn("new-session", "fresh"));
+  assert.notEqual(outcome, null, "addTurnBounded refused below capacity");
+  await buffer.addTurn("overflow", makeTurn("overflow", "one too many"));
+  // The evicted key's file deletion lands on the next persist, like any
+  // other buffered state change.
+  await buffer.flushPendingSave();
+  assert.ok(storage.deleted.includes("s0"), "oldest session was not evicted under capacity pressure");
+  assert.ok(
+    storage.deleted.length > 0,
+    "capacity pressure evicted entries without deleting their session files",
+  );
+  for (const key of storage.deleted) {
+    assert.equal(storage.sessions.has(key), false, `evicted session ${key} still has a file record`);
+  }
+});
+
+test("resetToEmpty drops every session file on the next persist", async () => {
+  const storage = new IncrementalStorage(emptyState());
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 }), storage);
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "alpha"));
+  await buffer.flushPendingSave();
+  buffer.resetToEmpty();
+  await buffer.flushPendingSave();
+  // resetToEmpty marks every known key for deletion; deleting a key whose
+  // file never existed is an ENOENT no-op on real storage (covered in the
+  // storage contract tests). The session that HAD a file must be gone.
+  assert.ok(storage.deleted.includes("thread-a"));
+  assert.equal(storage.sessions.size, 0);
+});
+
+test("retained turns survive the per-session persist", async () => {
+  const storage = new IncrementalStorage(emptyState());
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 }), storage);
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "alpha"));
+  await buffer.flushPendingSave();
+  await buffer.retainDeferredTurns("thread-a", [makeTurn("thread-a", "alpha")], 5);
+  await buffer.flushPendingSave();
+
+  const record = storage.sessions.get("thread-a");
+  assert.equal(record?.entry.retainedTurns?.length, 1, "retained turns were not persisted");
+  assert.equal(record?.entry.retainedTurns?.[0]?.content, "alpha");
+});
+
+test("buffer state survives a restart through per-session files", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-bufio-restart-"));
+  try {
+    const storage = new StorageManager(root);
+    const config = parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 });
+    const first = new SmartBuffer(config, storage);
+    await first.addTurn("thread-a", makeTurn("thread-a", "alpha"));
+    await first.addTurn("thread-b", makeTurn("thread-b", "beta"));
+    await first.flushPendingSave();
+
+    // A fresh process reads the buffer back from the per-session files.
+    const second = new SmartBuffer(config, storage);
+    await second.load();
+    assert.equal(second.getTurns("thread-a").length, 1);
+    assert.equal(second.getTurns("thread-a")[0]?.content, "alpha");
+    assert.equal(second.getTurns("thread-b")[0]?.content, "beta");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("legacy-only storage keeps the whole-state saveBuffer behavior", async () => {
+  const storage = new LegacyOnlyStorage(emptyState());
+  const buffer = new SmartBuffer(parseConfig({ triggerMode: "every_n", bufferMaxTurns: 100 }), storage);
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "alpha"));
+  await buffer.flushPendingSave();
+  await buffer.addTurn("thread-b", makeTurn("thread-b", "beta"));
+  await buffer.flushPendingSave();
+
+  assert.ok(storage.wholeStateSaves >= 2, "legacy storage did not receive whole-state saves");
+  assert.equal(storage.lastSaved?.entries?.["thread-a"]?.turns[0]?.content, "alpha");
+  assert.equal(storage.lastSaved?.entries?.["thread-b"]?.turns[0]?.content, "beta");
+});

package/src/buffer-persistence.ts

@@ -0,0 +1,89 @@
+import type { BufferEntryState, BufferState, BufferSurpriseEvent } from "./types.js";
+
+/**
+ * The buffer persistence surface SmartBuffer depends on.
+ *
+ * `saveBufferSession` / `deleteBufferSession` are the per-session incremental
+ * writes (one file per session); when a storage backend does not provide
+ * them, the buffer falls back to the whole-state `saveBuffer`. Both are
+ * optional in the type so a storage double only has to implement what it
+ * actually supports.
+ */
+export interface BufferStorage {
+  loadBuffer(): Promise<BufferState>;
+  saveBuffer(state: BufferState): Promise<void>;
+  saveBufferSession?(key: string, entry: BufferEntryState): Promise<void>;
+  deleteBufferSession?(key: string): Promise<void>;
+  /** Optional surprise-telemetry sink; older storage and test doubles omit it. */
+  appendBufferSurpriseEvents?(events: BufferSurpriseEvent[]): Promise<number>;
+}
+
+/**
+ * Tracks which sessions' persisted files are stale and writes only those.
+ *
+ * Marks are cleared only after a durable write of that session. All calls
+ * happen under SmartBuffer's serialized mutation chain: one writer.
+ */
+export class BufferSessionPersistence {
+  private readonly dirty = new Set<string>();
+  private readonly deleted = new Set<string>();
+
+  markDirty(key: string): void {
+    this.dirty.add(key);
+    this.deleted.delete(key);
+  }
+
+  markDeleted(key: string): void {
+    this.deleted.add(key);
+    this.dirty.delete(key);
+  }
+
+  /** Eviction removed `key` from memory: its session file must go, any pending write is moot. */
+  markEvicted(keys: readonly string[]): void {
+    for (const key of keys) this.markDeleted(key);
+  }
+
+  hasPending(): boolean {
+    return this.dirty.size > 0 || this.deleted.size > 0;
+  }
+
+  /**
+   * Persist buffer state. On session-capable storage this writes ONLY the
+   * sessions whose state changed since the last successful persist and
+   * deletes files for evicted/reset sessions, so the observe path never
+   * re-serializes other sessions' turns. On legacy storage it falls back to
+   * the whole-state saveBuffer. Files are deleted before dirty writes: a
+   * crash mid-persist can then only resurrect already-evicted data (the same
+   * exposure as a whole-file rewrite), never drop sessions the state says
+   * exist.
+   */
+  async persist(
+    storage: BufferStorage,
+    state: BufferState,
+    peekEntry: (key: string) => BufferEntryState | undefined,
+  ): Promise<void> {
+    const saveSession = storage.saveBufferSession?.bind(storage);
+    const deleteSession = storage.deleteBufferSession?.bind(storage);
+    if (!saveSession || !deleteSession) {
+      await storage.saveBuffer(state);
+      this.dirty.clear();
+      this.deleted.clear();
+      return;
+    }
+    for (const key of [...this.deleted]) {
+      await deleteSession(key);
+      this.deleted.delete(key);
+    }
+    for (const key of [...this.dirty]) {
+      const entry = peekEntry(key);
+      if (!entry) {
+        // A dirty key without state must not be written from a fabricated
+        // empty entry: treat it as a deletion instead.
+        this.markDeleted(key);
+        continue;
+      }
+      await saveSession(key, entry);
+      this.dirty.delete(key);
+    }
+  }
+}