@morlay/session-rdb 0.0.18 → 0.0.20

package/drizzle/sqlite/20260910130000_v3_session_title_backfill/snapshot.json

@@ -2,9 +2,7 @@
   "version": "7",
   "dialect": "sqlite",
   "id": "9f0f3ef7-6951-441e-ac74-b4eb613de8b4",
-  "prevIds": [
-    "1d8acf30-2759-4afb-9aa6-81ee2b470237"
-  ],
+  "prevIds": ["1d8acf30-2759-4afb-9aa6-81ee2b470237"],
   "ddl": [
     {
       "name": "t_events",
@@ -357,13 +355,9 @@
       "table": "t_sessions"
     },
     {
-      "columns": [
-        "f_session_id"
-      ],
+      "columns": ["f_session_id"],
       "tableTo": "t_sessions",
-      "columnsTo": [
-        "f_session_id"
-      ],
+      "columnsTo": ["f_session_id"],
       "onUpdate": "NO ACTION",
       "onDelete": "CASCADE",
       "nameExplicit": false,
@@ -372,13 +366,9 @@
       "table": "t_session_events"
     },
     {
-      "columns": [
-        "f_event_id"
-      ],
+      "columns": ["f_event_id"],
       "tableTo": "t_events",
-      "columnsTo": [
-        "f_event_id"
-      ],
+      "columnsTo": ["f_event_id"],
       "onUpdate": "NO ACTION",
       "onDelete": "CASCADE",
       "nameExplicit": false,
@@ -387,45 +377,35 @@
       "table": "t_session_events"
     },
     {
-      "columns": [
-        "f_id"
-      ],
+      "columns": ["f_id"],
       "nameExplicit": false,
       "name": "t_events_pk",
       "table": "t_events",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_singleton"
-      ],
+      "columns": ["f_singleton"],
       "nameExplicit": false,
       "name": "t_persistence_state_pk",
       "table": "t_persistence_state",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_key"
-      ],
+      "columns": ["f_key"],
       "nameExplicit": false,
       "name": "t_schema_meta_pk",
       "table": "t_schema_meta",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_id"
-      ],
+      "columns": ["f_id"],
       "nameExplicit": false,
       "name": "t_session_events_pk",
       "table": "t_session_events",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_id"
-      ],
+      "columns": ["f_id"],
       "nameExplicit": false,
       "name": "t_sessions_pk",
       "table": "t_sessions",
@@ -502,28 +482,21 @@
       "table": "t_session_events"
     },
     {
-      "columns": [
-        "f_session_id",
-        "f_sequence"
-      ],
+      "columns": ["f_session_id", "f_sequence"],
       "nameExplicit": true,
       "name": "uq_session_events_session_sequence",
       "entityType": "uniques",
       "table": "t_session_events"
     },
     {
-      "columns": [
-        "f_event_id"
-      ],
+      "columns": ["f_event_id"],
       "nameExplicit": false,
       "name": "t_events_f_event_id_unique",
       "entityType": "uniques",
       "table": "t_events"
     },
     {
-      "columns": [
-        "f_session_id"
-      ],
+      "columns": ["f_session_id"],
       "nameExplicit": false,
       "name": "t_sessions_f_session_id_unique",
       "entityType": "uniques",
@@ -816,74 +789,56 @@
       "table": "t_workspace_sessions"
     },
     {
-      "columns": [
-        "f_id"
-      ],
+      "columns": ["f_id"],
       "nameExplicit": false,
       "name": "t_session_projcache_row_pk",
       "table": "t_session_projcache_row",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_name"
-      ],
+      "columns": ["f_name"],
       "nameExplicit": false,
       "name": "t_storage_units_pk",
       "table": "t_storage_units",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_singleton"
-      ],
+      "columns": ["f_singleton"],
       "nameExplicit": false,
       "name": "t_workspace_state_pk",
       "table": "t_workspace_state",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_id"
-      ],
+      "columns": ["f_id"],
       "nameExplicit": false,
       "name": "t_workspaces_pk",
       "table": "t_workspaces",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_id"
-      ],
+      "columns": ["f_id"],
       "nameExplicit": false,
       "name": "t_workspace_sessions_pk",
       "table": "t_workspace_sessions",
       "entityType": "pks"
     },
     {
-      "columns": [
-        "f_session_id",
-        "f_key"
-      ],
+      "columns": ["f_session_id", "f_key"],
       "nameExplicit": true,
       "name": "uq_session_projcache_row_session_key",
       "entityType": "uniques",
       "table": "t_session_projcache_row"
     },
     {
-      "columns": [
-        "f_workspace_id"
-      ],
+      "columns": ["f_workspace_id"],
       "nameExplicit": false,
       "name": "t_workspaces_f_workspace_id_unique",
       "entityType": "uniques",
       "table": "t_workspaces"
     },
     {
-      "columns": [
-        "f_workspace_id",
-        "f_session_id"
-      ],
+      "columns": ["f_workspace_id", "f_session_id"],
       "nameExplicit": true,
       "name": "uq_workspace_sessions_workspace_session",
       "entityType": "uniques",
@@ -924,13 +879,9 @@
       "table": "t_workspace_state"
     },
     {
-      "columns": [
-        "f_session_id"
-      ],
+      "columns": ["f_session_id"],
       "tableTo": "t_sessions",
-      "columnsTo": [
-        "f_session_id"
-      ],
+      "columnsTo": ["f_session_id"],
       "onUpdate": "NO ACTION",
       "onDelete": "CASCADE",
       "nameExplicit": false,
@@ -939,13 +890,9 @@
       "table": "t_session_projcache_row"
     },
     {
-      "columns": [
-        "f_workspace_id"
-      ],
+      "columns": ["f_workspace_id"],
       "tableTo": "t_workspaces",
-      "columnsTo": [
-        "f_workspace_id"
-      ],
+      "columnsTo": ["f_workspace_id"],
       "onUpdate": "NO ACTION",
       "onDelete": "CASCADE",
       "nameExplicit": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/session-rdb",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "RDB durable session backend for DeepSeek Harness: implements both session-persistence and session-branch (rewind / retry / fork) providers.",
   "keywords": [
     "branch",
@@ -35,7 +35,7 @@
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
   "dependencies": {
-    "@morlay/session-branch": "^0.0.6",
+    "@morlay/session-branch": "^0.0.8",
     "drizzle-orm": "^1.0.0-rc.5-ab785fc",
     "fflate": "^0.8.2",
     "pg": "^8.23.0"
@@ -60,6 +60,7 @@
     "@deepseek-ai/dsh-session-format": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-session-format-catalog": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-session-persistence": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-session-query": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-settings": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-storage": "^0.1.5-rc.2",
     "@deepseek-ai/schemastery": "^3.18.2"
@@ -81,7 +82,7 @@
     "magic-string": "0.30.21",
     "tinyrainbow": "3.1.1",
     "vitest": "4.1.11",
-    "zod": "4.6.1"
+    "zod": "4.6.5"
   },
   "scripts": {
     "build": "pnpm exec tsdown",

package/src/entities/v3/workspace-state.ts

@@ -4,7 +4,7 @@ import type { TableDef } from "../../adapters/types.ts";
  * workspace 域 global 单例（上游 `workspaceDomainState`）：`initialized` 是
  * 引导标记，`pendingMutation` 拆成操作与目标两列（create / delete 的可恢复
  * 两写标记）。显示顺序（`workspaceIds`）在 `t_workspaces.f_position`，
- * 归档集在 `t_session_archives`。
+ * 归档集由 `t_sessions.f_archived_at` 承载（归档不触碰归属槽位）。
  */
 export const workspaceState: TableDef = {
   name: "t_workspace_state",

package/src/import-storages.ts

@@ -42,9 +42,11 @@ export interface StoragesImportOptions {
 }
 
 const WORKSPACE_UNIT = "workspace";
-const WORKSPACE_UNIT_VERSIONS = new Set([2]);
+/** 旧 workspace 文档可接受的域版本集（对齐上游 `workspaceDomainSpec`，见对齐测试）。 */
+export const WORKSPACE_UNIT_VERSIONS: ReadonlySet<number> = new Set([2]);
 const PROJCACHE_UNIT = "session_projcache";
-const PROJCACHE_UNIT_VERSIONS = new Set([7, 3, 4, 5, 6]);
+/** 旧投影缓存文档可接受的域版本集（对齐上游 spec 的 version ∪ compatibleVersions）。 */
+export const PROJCACHE_UNIT_VERSIONS: ReadonlySet<number> = new Set([7, 3, 4, 5, 6]);
 
 /**
  * Import the legacy storages documents into the rdb tables.
@@ -62,7 +64,10 @@ export async function importStorages(
   const workspaceDocument = await readJson(join(storagesRoot, `${WORKSPACE_UNIT}.json`));
   if (workspaceDocument !== undefined) {
     const tables = unitTables(workspaceDocument, WORKSPACE_UNIT, WORKSPACE_UNIT_VERSIONS);
-    await repository.insertUnitVersion(WORKSPACE_UNIT, WORKSPACE_UNIT_VERSIONS.values().next().value as number);
+    await repository.insertUnitVersion(
+      WORKSPACE_UNIT,
+      WORKSPACE_UNIT_VERSIONS.values().next().value as number,
+    );
     for (const [id, record] of Object.entries(tables["workspaces"] ?? {})) {
       await repository.putWorkspace(id, record as WorkspaceRecord);
       result.workspaces += 1;

package/src/import.ts

@@ -2,12 +2,14 @@ import { randomUUID } from "node:crypto";
 import type { Context } from "@deepseek-ai/cordis";
 import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import type { Session, SessionEvent, SessionId, SessionHeader } from "@deepseek-ai/dsh-session";
+import { parseSessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
 import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
 import { unzipSync } from "fflate";
 import { replaceLiveSessionLog } from "./branch.ts";
 import type { SessionPersistenceRdb } from "./index.ts";
 
+/** 当前世代产物的文件名（读入侧接受任意 canonical 世代名，见 parseImportZip）。 */
 export const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
 
 export const SESSION_IMPORT_PATH = "/api/session.import";
@@ -107,11 +109,36 @@ export function parseImportZip(zip: Uint8Array): SessionStorageMetadata & {
   } catch {
     throw new Error("imported zip is not a valid ZIP archive");
   }
-  const artifact = entries[SESSION_LOG_ARTIFACT_FILENAME];
+  // 上游导出按世代命名（`session.v3.jsonl`），早期 rdb 导出沿用 `session.jsonl`：
+  // 两者都接受，按 canonical 名字规则识别（临时/大写/压缩后缀名不视为产物）。
+  const artifact = Object.entries(entries).find(
+    ([name]) => parseSessionFormatLogFilename(name) !== undefined,
+  );
   if (artifact === undefined) {
-    throw new Error(`imported zip is missing ${SESSION_LOG_ARTIFACT_FILENAME}`);
+    throw new Error(
+      `imported zip has no session log artifact (expected ${SESSION_LOG_ARTIFACT_FILENAME} ` +
+        "or a canonical session.vN.jsonl)",
+    );
   }
-  return parseJsonlArtifact(new TextDecoder().decode(artifact));
+  return parseJsonlArtifact(new TextDecoder().decode(artifact[1]));
+}
+
+// 上游 Agent 的取消面（duck-type）：停止运行中的 loop。
+interface ImportAgentLike {
+  cancel?(cause: { kind: "user" }, options?: { keepInbox?: boolean }): void;
+  whenIdle(): Promise<void>;
+}
+
+// persistImport 会先 rewind(-1) 截断 live 会话的内存 log，不能与 agent 写日志
+// 并发；keepInbox 保留排队输入（截断后由 rewind 的 live 钩子 durable 取消）。
+async function stopAgentLoop(ctx: Context, sessionId: SessionId): Promise<void> {
+  const agents = ctx.get("agents") as
+    | { get(id: SessionId): ImportAgentLike | undefined }
+    | undefined;
+  const agent = agents?.get(sessionId);
+  if (agent === undefined) return;
+  agent.cancel?.({ kind: "user" }, { keepInbox: true });
+  await agent.whenIdle();
 }
 
 export async function persistImport(
@@ -120,12 +147,15 @@ export async function persistImport(
   imported: SessionStorageMetadata & { events: SessionEvent[] },
   targetId?: SessionId,
   sessions?: { get(id: SessionId): Session | undefined },
+  stopLoop?: (id: SessionId) => Promise<void>,
 ): Promise<SessionId> {
   const id = targetId ?? (`session-${randomUUID()}` as SessionId);
   if (targetId !== undefined) {
     if (branch === undefined) {
       throw new Error("sessionBranch service is unavailable");
     }
+    // 覆盖语义先 rewind(-1) 截断：停止运行中的 loop（未注入端口时空操作）。
+    if (stopLoop !== undefined) await stopLoop(targetId);
     await branch.rewind(targetId, -1);
     // rewind 截断后追加导入事件（覆盖语义）。live 会话的 write handle 由
     // live 路由持有——复用而非 open（open 会撞 SessionAlreadyOwnedError）。
@@ -252,7 +282,14 @@ export function registerSessionImport(ctx: Context, persistence: SessionPersiste
               const sessions = webCtx.get("sessions") as
                 | { get(id: SessionId): Session | undefined }
                 | undefined;
-              const id = await persistImport(persistence, branch, imported, targetId, sessions);
+              const id = await persistImport(
+                persistence,
+                branch,
+                imported,
+                targetId,
+                sessions,
+                (sessionId) => stopAgentLoop(webCtx, sessionId),
+              );
               res.writeHead(200, { "content-type": "application/json" });
               res.end(JSON.stringify({ sessionId: id }));
             } catch (error: unknown) {

package/src/index.ts

@@ -30,6 +30,7 @@ import {
   type SessionPersistenceStatOptions,
 } from "@deepseek-ai/dsh-session-persistence";
 import {
+  SESSION_FORMAT_VERSION,
   SessionLogOffset,
   type Session,
   type SessionEvent,
@@ -37,6 +38,7 @@ import {
   type SessionId,
   type SurfaceEventType,
 } from "@deepseek-ai/dsh-session";
+import { sessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
 import { type Backend, type BackendTx, type EventInsert } from "./backend.ts";
 import { WriteGuard } from "./write-guard.ts";
 import { repairReadView, rowToMeta, scanRows, toJsonlArtifact } from "./log.ts";
@@ -50,6 +52,7 @@ import { SqliteBackend } from "./sqlite.ts";
 import { PostgresBackend } from "./postgres.ts";
 import { SessionBranchRdb } from "./branch.ts";
 import { registerSessionImport } from "./import.ts";
+import { SessionQueryRdb } from "./session-query.ts";
 import { adoptLegacyRows, convertLegacyRows, isLegacyVersion } from "./legacy.ts";
 import { installStorageTakeover } from "./storage-takeover/index.ts";
 
@@ -532,6 +535,10 @@ export class SessionPersistenceRdb extends SessionPersistence {
     this.installLiveRouting(ctx);
     // 分支 provider 服务（rewind / forkFrom / timeline），随 fiber 卸载自动回滚。
     new SessionBranchRdb(this.ctx);
+    // 会话查询服务：接管官方 session-query-sqlite（同名 provide 会 fail loud，
+    // 其装配行由 better-session patch 禁用）；class-plugin 装载以复用基类的
+    // 精确读 / 过滤 / 血缘实现。
+    this.ctx.plugin(SessionQueryRdb, {});
     // 导入端点：webServer + connection 就绪后注册 `/api/session.import`。
     registerSessionImport(this.ctx, this);
     // storages 接管：storage hub 的 `rdb` 后端（workspace 域）与
@@ -706,7 +713,7 @@ export class SessionPersistenceRdb extends SessionPersistence {
 
   // --- RDB 特有能力（rewind / fork / 导出 / 测试支撑） ---
 
-  /** 导出 artifact（jsonl v2 文本），视图只读不落库。 */
+  /** 导出当前世代的 jsonl artifact，视图只读不落库。 */
   async readRaw(
     id: SessionId,
     signal?: AbortSignal,
@@ -724,7 +731,8 @@ export class SessionPersistenceRdb extends SessionPersistence {
     return {
       meta: log.meta,
       inheritedEventCount,
-      filename: "session.jsonl",
+      // 内容按当前世代编码，文件名必须声明同一世代（上游导出用 session.vN.jsonl）。
+      filename: sessionFormatLogFilename(SESSION_FORMAT_VERSION),
       content: toJsonlArtifact(log.meta, inheritedEventCount, log.events),
     };
   }

package/src/postgres.ts

@@ -60,16 +60,22 @@ export class PostgresBackend implements Backend {
     this.opened.catch(() => {});
     this.storage = createStorageRepository({
       db: () => this.opened.then(() => this.txOverride ?? this.db),
+      // storages 写事务用 serializable：workspace 域是整记录替换，多实例并发写
+      // 同一记录在 read committed 下是「最后提交者赢」的静默覆盖；提升隔离级别
+      // 后冲突以序列化失败暴露（与「并发写入 fail loud」一致），调用方重试即可。
       writeAtomically: (fn) =>
-        this.db.transaction(async (tx) => {
-          const previous = this.txOverride;
-          this.txOverride = tx;
-          try {
-            return await fn();
-          } finally {
-            this.txOverride = previous;
-          }
-        }),
+        this.db.transaction(
+          async (tx) => {
+            const previous = this.txOverride;
+            this.txOverride = tx;
+            try {
+              return await fn();
+            } finally {
+              this.txOverride = previous;
+            }
+          },
+          { isolationLevel: "serializable" },
+        ),
       tables: this.tables,
     });
   }

package/src/session-query.ts

@@ -0,0 +1,27 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { SessionQueryEngine, SessionQueryError, type Config } from "@deepseek-ai/dsh-session-query";
+
+// 会话查询服务的 rdb 实现：精确读 / 过滤 / 血缘全部复用上游基类（数据面走
+// ctx.sessions 与我们的 ctx.sessionPersistence），这里只接管服务所有权。
+// 全文检索与官方 `openAt: never` 装配保持一致——直接拒绝，不引入 FTS 索引、
+// node:sqlite 或派生库，搜索语义留待显式实现（见 ADR 0006）。
+export class SessionQueryRdb extends SessionQueryEngine {
+  constructor(ctx: Context, config: Config = {}) {
+    super(ctx, config);
+  }
+
+  override async searchSessions(): Promise<never> {
+    throw searchDisabled();
+  }
+
+  override async searchEvents(): Promise<never> {
+    throw searchDisabled();
+  }
+}
+
+function searchDisabled(): SessionQueryError {
+  return new SessionQueryError(
+    "session search is disabled: this deployment serves session queries from the rdb backend without a full-text index",
+    "SESSION_QUERY_SEARCH_DISABLED",
+  );
+}

package/src/storage-takeover/index.ts

@@ -48,13 +48,13 @@ export function installStorageTakeover(ctx: Context, options: StorageTakeoverOpt
     storageCtx.provide(storageBackendServiceKey(RDB_STORAGE_BACKEND), backend);
   });
 
-  // 投影 checkpoint：上游插件被禁用后由本服务提供同名 API。
-  ctx.inject(["sessionProjections"], (projectionCtx) => {
-    new SessionProjectionCacheRdb(
-      projectionCtx,
-      options.projectionCache,
-      options.repository,
-      options.ready,
-    );
+  // 投影 checkpoint：上游插件被禁用后由本服务提供同名 API。按 cordis
+  // class plugin 装载（而不是直接 new）：`static inject` 负责等依赖就绪，
+  // 框架负责调用 `[Service.init]` 安装写入路径——直接 new 会静默跳过 init，
+  // 导致 session/created、turn/end、计数与定时器的 checkpoint 写入全部失效。
+  ctx.plugin(SessionProjectionCacheRdb, {
+    ...options.projectionCache,
+    repository: options.repository,
+    ready: options.ready,
   });
 }

package/src/storage-takeover/projection-cache.ts

@@ -49,6 +49,12 @@ export interface ProjectionCacheConfig {
   writeIntervalMs: number;
 }
 
+/** class-plugin 装载参数：写节流 + storages 接管访问层 + 介质就绪信号。 */
+export interface SessionProjectionCacheRdbOptions extends ProjectionCacheConfig {
+  repository: StorageRepository;
+  ready: Promise<unknown>;
+}
+
 /** 每会话写回节流簿记（只对 live session）。 */
 interface DirtyState {
   pending: number;
@@ -67,35 +73,48 @@ export class SessionProjectionCacheRdb extends Service {
   private readonly dirty = new Map<Session, DirtyState>();
   /** 读路径是否直读介质（`readProjcacheSync` 存在即同步驱动）。 */
   private readonly directReads: boolean;
+  private readonly config: ProjectionCacheConfig;
+  private readonly repository: StorageRepository;
+  private readonly ready: Promise<unknown>;
 
   /**
-   * @param ctx - 插件上下文（须已注入 sessionProjections 与 sessions）。
-   * @param config - 写节流参数。
-   * @param repository - storages 接管表访问层。
-   * @param ready - 介质就绪信号（直读介质前必须等到）。
+   * 本类按 cordis class plugin 装载（`ctx.plugin(SessionProjectionCacheRdb, options)`）：
+   * `static inject` 等依赖就绪后构造，构造后框架调用 `[Service.init]` 安装写入
+   * 路径——直接 `new` 不会触发 init，写入路径会静默缺失。
+   * @param ctx - 插件上下文（已注入 sessionProjections 与 sessions）。
+   * @param options - 写节流 + storages 接管访问层 + 介质就绪信号。
    */
-  constructor(
-    ctx: Context,
-    private readonly config: ProjectionCacheConfig,
-    private readonly repository: StorageRepository,
-    private readonly ready: Promise<unknown>,
-  ) {
+  constructor(ctx: Context, options: SessionProjectionCacheRdbOptions) {
     super(ctx, SESSION_PROJECTION_CACHE_SERVICE);
-    this.directReads = repository.readProjcacheSync !== undefined;
+    this.config = options;
+    this.repository = options.repository;
+    this.ready = options.ready;
+    this.directReads = options.repository.readProjcacheSync !== undefined;
   }
 
   /**
-   * Wait for the medium, then install the write path. Only the async driver
-   * needs a startup mirror: the sync driver serves every read from the table.
+   * Install the write path before the async medium wait: listeners must exist
+   * from plugin activation on, or sessions created while the medium settles
+   * lose their mandatory checkpoints. Only the async driver needs the startup
+   * mirror; the sync driver serves every read from the table.
    */
   protected async [Service.init](): Promise<void> {
+    this.installWritePath();
     await this.ready;
+    // 一次性清理旧版写入路径留下的陈旧行（水位为负却已有事件）：这些行会把
+    // 有对话的会话在 cold 列表里误判为空白。缓存是派生数据，删除让会话回到
+    // 「未知即可见」，等待下一次强制点重写。
+    const pruned = await this.repository.pruneStaleProjcache();
+    if (pruned > 0) {
+      this.ctx.logger.info(
+        `session projection cache: pruned stale snapshot(s) for ${String(pruned)} session(s)`,
+      );
+    }
     if (!this.directReads) {
       for (const entry of await this.repository.loadProjcache()) {
         this.records.set(entry.sessionId as SessionId, entry);
       }
     }
-    this.installWritePath();
   }
 
   /** Read one session's stored record: straight from the medium, or from the async mirror. */
@@ -113,7 +132,10 @@ export class SessionProjectionCacheRdb extends Service {
    * @param expected - the log identity the caller holds (live or stored header).
    * @returns the identity-matching record, or `undefined` (absent or unrelated).
    */
-  private recordFor(id: SessionId, expected: CurrentCheckpointIdentity): StoredProjcacheEntry | undefined {
+  private recordFor(
+    id: SessionId,
+    expected: CurrentCheckpointIdentity,
+  ): StoredProjcacheEntry | undefined {
     const record = this.lookup(id);
     if (record === undefined) return undefined;
     return identityMatches(record.identity, expected) ? record : undefined;
@@ -329,12 +351,15 @@ export class SessionProjectionCacheRdb extends Service {
       this.dirty.delete(session);
     });
 
-    this.ctx.effect(() => () => {
-      for (const state of this.dirty.values()) {
-        if (state.timer !== undefined) clearTimeout(state.timer);
-      }
-      this.dirty.clear();
-    }, "sessionProjectionCacheRdb.timers");
+    this.ctx.effect(
+      () => () => {
+        for (const state of this.dirty.values()) {
+          if (state.timer !== undefined) clearTimeout(state.timer);
+        }
+        this.dirty.clear();
+      },
+      "sessionProjectionCacheRdb.timers",
+    );
   }
 
   /** One fail-soft durable checkpoint. */
@@ -374,7 +399,9 @@ export class SessionProjectionCacheRdb extends Service {
 }
 
 /** Detach one checkpoint from live unit state, refusing non-lossless JSON. */
-function detachJson(rows: Record<string, ProjectionCheckpointRow>): Record<string, ProjectionCheckpointRow> {
+function detachJson(
+  rows: Record<string, ProjectionCheckpointRow>,
+): Record<string, ProjectionCheckpointRow> {
   let text: string | undefined;
   try {
     text = JSON.stringify(rows);
@@ -416,8 +443,7 @@ function identityOf(
  */
 function identityMatches(stored: CheckpointIdentity, expected: CurrentCheckpointIdentity): boolean {
   return (
-    stored.formatVersion === expected.formatVersion &&
-    lifecycleIdentityMatches(stored, expected)
+    stored.formatVersion === expected.formatVersion && lifecycleIdentityMatches(stored, expected)
   );
 }