@morlay/session-rdb 0.0.16 → 0.0.18

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { a as SCHEMA_VERSION, g as WriteGuard, h as toPostgresSchema, i as EVENT_ENCODING, m as postgresTableDefs, r as DEFAULT_BUSY_TIMEOUT_MS, s as eventDimensions, t as SqliteBackend } from "./sqlite-IH5I48aL.mjs";
-import { c as repairRequestHeaders, d as rowToMeta, f as scanRows, g as toJsonlArtifact, m as sessionInsertRow, p as sessionConflictRow, s as repairReadView } from "./log-BIuXv09P.mjs";
-import { c as SessionBranchRdbProvider, l as locateTurnEnd, o as registerSessionImport, s as SessionBranchRdb } from "./import-BPEHfHNk.mjs";
+import { S as WriteGuard, a as EVENT_ENCODING, b as postgresTableDefs, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, o as SCHEMA_VERSION, r as createStorageRepository, t as SqliteBackend, x as toPostgresSchema } from "./sqlite-BIPdMNQb.mjs";
+import { _ as toJsonlArtifact, c as repairRequestHeaders, d as rowToMeta, f as scanRows, g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, s as repairReadView } from "./log-DO69NQnn.mjs";
+import { c as SessionBranchRdbProvider, l as locateTurnEnd, o as registerSessionImport, s as SessionBranchRdb } from "./import-DZIAjOUr.mjs";
 import z from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
 import { Pool } from "pg";
@@ -8,10 +8,12 @@ import { drizzle } from "drizzle-orm/node-postgres";
 import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionHandleClosedError, SessionPersistence, SessionPersistenceNotFoundError, SessionPersistenceRevision, SessionReadOnlyError, assertContiguous, assertVersion, materializeAppendBatch, materializeCreateHeader, validateStoredEvents } from "@deepseek-ai/dsh-session-persistence";
 import { SESSION_FORMAT_VERSION, SessionLogOffset } from "@deepseek-ai/dsh-session";
 import { sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
-import { and, eq, gte, sql } from "drizzle-orm";
+import { and, desc, eq, gte, sql } from "drizzle-orm";
 import { readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { StorageError, storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
+import { Service } from "@deepseek-ai/cordis";
 //#region src/postgres.ts
 /** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
 const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
@@ -21,12 +23,46 @@ var PostgresBackend = class PostgresBackend {
 	kind = "postgres";
 	storeIdentity;
 	tables;
+	/** storages 接管表访问层；句柄在 open()（含迁移）完成后解析。 */
+	storage;
+	opened;
+	resolveOpened;
+	rejectOpened;
+	/** 事务期间的连接覆盖：storage 写方法经它加入当前事务。 */
+	txOverride;
 	constructor(db, options) {
 		this.db = db;
 		this.options = options;
 		this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
+		this.opened = new Promise((resolve, reject) => {
+			this.resolveOpened = resolve;
+			this.rejectOpened = reject;
+		});
+		this.opened.catch(() => {});
+		this.storage = createStorageRepository({
+			db: () => this.opened.then(() => this.txOverride ?? this.db),
+			writeAtomically: (fn) => this.db.transaction(async (tx) => {
+				const previous = this.txOverride;
+				this.txOverride = tx;
+				try {
+					return await fn();
+				} finally {
+					this.txOverride = previous;
+				}
+			}),
+			tables: this.tables
+		});
 	}
 	async open() {
+		try {
+			await this.doOpen();
+			this.resolveOpened();
+		} catch (error) {
+			this.rejectOpened(error);
+			throw error;
+		}
+	}
+	async doOpen() {
 		const schema = this.options.schema ?? "public";
 		const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
 		if ((await this.db.execute(sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`)).rows[0]?.exists === true) {
@@ -87,6 +123,7 @@ var PostgresBackend = class PostgresBackend {
 			insertBridges: (rows) => this.insertBridges(tx, rows),
 			updateHead: (id, headEventId, headSequence) => this.updateHead(tx, id, headEventId, headSequence),
 			bumpRevision: (id) => this.bumpRevision(tx, id),
+			refreshTitle: (id) => this.refreshTitle(tx, id),
 			deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
 			getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence)
 		};
@@ -136,6 +173,20 @@ var PostgresBackend = class PostgresBackend {
 	async bumpRevision(exec, id) {
 		await exec.update(this.tables["t_sessions"]).set({ fRevision: sql`${this.tables["t_sessions"].fRevision} + 1` }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
 	}
+	/** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
+	async refreshTitle(exec, id) {
+		const bridges = this.tables["t_session_events"];
+		const entities = this.tables["t_events"];
+		const row = (await exec.select({
+			fSequence: bridges.fSequence,
+			fData: entities.fData
+		}).from(bridges).innerJoin(entities, eq(entities.fEventId, bridges.fEventId)).where(and(eq(bridges.fSessionId, id), eq(entities.fType, "session/title"))).orderBy(desc(bridges.fSequence)).limit(1).execute())[0];
+		const title = row === void 0 ? void 0 : titleOfEventData(row.fData);
+		await exec.update(this.tables["t_sessions"]).set({
+			fTitle: title ?? null,
+			fTitleSeq: title === void 0 ? null : row.fSequence
+		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+	}
 	async deleteBridgeTail(exec, id, fromSequence) {
 		await exec.delete(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence))).execute();
 	}
@@ -250,7 +301,436 @@ function adoptLegacyRows(row, eventRows) {
 	};
 }
 //#endregion
+//#region src/storage-takeover/projection-cache.ts
+/**
+* 投影 checkpoint 服务（`ctx.sessionProjectionCache`）的 rdb 实现：替换上游
+* `@deepseek-ai/dsh-session-projection-cache` 插件，公开面与语义逐一对齐
+* （cachedSnapshot / cachedPredecessorTitle / hydratePrepared / write /
+* coldSnapshot，以及三个强制写点与计数/定时节流），持久层换成 session-rdb
+* 的语义专用表 `t_session_projcache` / `t_session_projcache_row`。
+*
+* 读方法是同步签名（session 列表在请求路径上直接调用），所以服务持有启动时
+* 从表中加载的内存 checkpoint 表；写先落库、后更新内存，保证读到的内存值
+* 磁盘上一定存在。
+*/
+/** 服务注册名（与上游插件一致，消费者经 `ctx.get` 解析）。 */
+const SESSION_PROJECTION_CACHE_SERVICE = "sessionProjectionCache";
+/** 只认 title 的前代提示（与上游一致）。 */
+const PREDECESSOR_TITLE_KEY = "title";
+/** rdb 持久化的投影 checkpoint 服务：同步驱动直读介质，异步驱动用写穿镜像支撑同步签名。 */
+var SessionProjectionCacheRdb = class extends Service {
+	config;
+	repository;
+	ready;
+	static inject = ["sessionProjections", "sessions"];
+	/** 异步驱动（PostgreSQL）的同步读镜像：同步驱动（SQLite）直读介质，这里恒为空。 */
+	records = /* @__PURE__ */ new Map();
+	dirty = /* @__PURE__ */ new Map();
+	/** 读路径是否直读介质（`readProjcacheSync` 存在即同步驱动）。 */
+	directReads;
+	/**
+	* @param ctx - 插件上下文（须已注入 sessionProjections 与 sessions）。
+	* @param config - 写节流参数。
+	* @param repository - storages 接管表访问层。
+	* @param ready - 介质就绪信号（直读介质前必须等到）。
+	*/
+	constructor(ctx, config, repository, ready) {
+		super(ctx, SESSION_PROJECTION_CACHE_SERVICE);
+		this.config = config;
+		this.repository = repository;
+		this.ready = ready;
+		this.directReads = repository.readProjcacheSync !== void 0;
+	}
+	/**
+	* 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.
+	*/
+	async [Service.init]() {
+		await this.ready;
+		if (!this.directReads) for (const entry of await this.repository.loadProjcache()) this.records.set(entry.sessionId, entry);
+		this.installWritePath();
+	}
+	/** Read one session's stored record: straight from the medium, or from the async mirror. */
+	lookup(id) {
+		if (this.directReads) return this.repository.readProjcacheSync?.(id);
+		return this.records.get(id);
+	}
+	/**
+	* The stored record for one session, accepted only when its bound log
+	* identity matches `expected`. A session id names a slot, not a lifecycle:
+	* a recreated id or a persistence store swapped under a surviving cache
+	* must not let an old record seed state folded from an unrelated log.
+	* @param id - the session whose record is read.
+	* @param expected - the log identity the caller holds (live or stored header).
+	* @returns the identity-matching record, or `undefined` (absent or unrelated).
+	*/
+	recordFor(id, expected) {
+		const record = this.lookup(id);
+		if (record === void 0) return void 0;
+		return identityMatches(record.identity, expected) ? record : void 0;
+	}
+	/**
+	* The cached projection cut for one stored (cold) or live header.
+	* @param meta - authoritative Session header.
+	* @param inheritedEventCount - exact inherited cut completing the lifecycle identity.
+	* @param keys - optional projection keys required by the caller's audience.
+	* @returns the cut (`asOfSeq` = lowest served-row watermark), or `undefined`
+	*   when no usable row exists for this lifecycle.
+	*/
+	cachedSnapshot(meta, inheritedEventCount, keys) {
+		const record = this.recordFor(meta.id, identityOf(meta, inheritedEventCount));
+		const snapshot = record === void 0 ? void 0 : this.viewRecord(record, keys);
+		return this.withDirectTitle(meta.id, keys, snapshot);
+	}
+	/**
+	* 标题是会话数据本身（`t_sessions.f_title`，由 rdb 写路径与 rewind 维护）：
+	* checkpoint 行里没有 title 时直接取该列，列表消费不依赖缓存行是否存在。
+	*/
+	withDirectTitle(id, keys, snapshot) {
+		if (keys !== void 0 && !keys.includes(PREDECESSOR_TITLE_KEY)) return snapshot;
+		if (snapshot?.values[PREDECESSOR_TITLE_KEY] !== void 0) return snapshot;
+		const direct = this.repository.readSessionTitleSync?.(id);
+		if (direct === void 0) return snapshot;
+		const values = {
+			...snapshot?.values,
+			[PREDECESSOR_TITLE_KEY]: direct.title
+		};
+		return {
+			asOfSeq: snapshot === void 0 ? direct.seq : Math.min(snapshot.asOfSeq, direct.seq),
+			values
+		};
+	}
+	/**
+	* Read only a predecessor checkpoint's title as a zero-I/O listing hint.
+	* @param meta - authoritative listed Session header.
+	* @param inheritedEventCount - exact inherited cut completing the lifecycle identity.
+	* @returns a title-only checkpoint view with `asOfSeq: -1`, or `undefined`
+	*   when the record is current, newer, unrelated, missing, or incompatible
+	*   with the title unit.
+	*/
+	cachedPredecessorTitle(meta, inheritedEventCount) {
+		const expected = identityOf(meta, inheritedEventCount);
+		const record = this.lookup(meta.id);
+		if (record === void 0 || !predecessorIdentityMatches(record.identity, expected)) return;
+		const title = this.viewRecord(record, [PREDECESSOR_TITLE_KEY]);
+		return title === void 0 ? void 0 : {
+			...title,
+			asOfSeq: -1
+		};
+	}
+	/** View selected wire rows and bind them to their lowest served watermark. */
+	viewRecord(record, keys) {
+		const values = this.ctx.sessionProjections.viewCheckpoint(record.rows, keys);
+		const servedKeys = Object.keys(values);
+		if (servedKeys.length === 0) return void 0;
+		const firstKey = servedKeys[0];
+		let asOfSeq = record.rows[firstKey].seq;
+		for (const key of servedKeys.slice(1)) {
+			const row = record.rows[key];
+			if (row.seq < asOfSeq) asOfSeq = row.seq;
+		}
+		return {
+			asOfSeq,
+			values
+		};
+	}
+	/**
+	* Hydrate projection cells for an already-prepared Session without another
+	* persistence read. The cache seeds matching rows; the supplied exact log
+	* advances every unit to the observation cut. No checkpoint is written
+	* because the logical observation may contain recovery events not yet durable.
+	* @param session - exact unpublished Session retained by persistence.
+	* @param events - exact logical event prefix represented by the observation.
+	* @returns all projection values at the event cut.
+	*/
+	hydratePrepared(session, events) {
+		const record = this.recordFor(session.id, identityOf(session.header, session.inheritedEventCount));
+		if (record === void 0) return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
+		try {
+			return this.ctx.sessionProjections.hydrate(session, record.rows, events, SessionLogOffset(0));
+		} catch {
+			return this.ctx.sessionProjections.hydrate(session, {}, events, SessionLogOffset(0));
+		}
+	}
+	/**
+	* Durably checkpoint one live session NOW (all mandatory points call this).
+	* NOT fail-soft — callers on the fail-soft paths contain it.
+	* @param session - the live session to checkpoint.
+	* @returns resolution after durability.
+	*/
+	async write(session) {
+		const rows = this.ctx.sessionProjections.checkpoint(session);
+		this.markClean(session);
+		if (this.ctx.sessions.get(session.id) === session) await this.ctx.sessions.flush(session);
+		await this.put(session.id, identityOf(session.header, session.inheritedEventCount), rows);
+	}
+	/**
+	* Cold-read one session's projections from its complete log. Each unit is
+	* seeded from the identity-checked cached rows and the refreshed checkpoint
+	* is written back (fail-soft, fire-and-forget).
+	* @param meta - the stored session header (identity witness).
+	* @param inheritedEventCount - exact inherited prefix length for projection initialization and identity.
+	* @param events - the session's complete log, in seq order.
+	* @returns the projection cut at the log end.
+	*/
+	coldSnapshot(meta, inheritedEventCount, events) {
+		const identity = identityOf(meta, inheritedEventCount);
+		const restored = this.ctx.sessionProjections.restore(this.recordFor(meta.id, identity)?.rows ?? {}, events, SessionLogOffset(0), meta, inheritedEventCount);
+		this.put(meta.id, identity, restored.checkpoint).catch((error) => {
+			this.ctx.logger.warn(`session projection cache: cold-read write-back for "${meta.id}" failed (cache stays stale): ${String(error)}`);
+		});
+		return restored.snapshot;
+	}
+	installWritePath() {
+		this.ctx.on("session/event", (session, event) => {
+			if (event.type === "turn/end") {
+				this.flushSoft(session, "turn/end");
+				return;
+			}
+			const state = this.dirty.get(session) ?? {
+				pending: 0,
+				timer: void 0
+			};
+			this.dirty.set(session, state);
+			state.pending += 1;
+			if (state.pending >= this.config.writeEveryEvents) {
+				this.flushSoft(session, "count threshold");
+				return;
+			}
+			state.timer ??= setTimeout(() => {
+				this.flushSoft(session, "interval");
+			}, this.config.writeIntervalMs);
+		});
+		this.ctx.on("session/created", (session) => {
+			this.flushSoft(session, "create");
+		});
+		this.ctx.on("session/disposed", (session) => {
+			this.flushSoft(session, "detach");
+			this.markClean(session);
+			this.dirty.delete(session);
+		});
+		this.ctx.effect(() => () => {
+			for (const state of this.dirty.values()) if (state.timer !== void 0) clearTimeout(state.timer);
+			this.dirty.clear();
+		}, "sessionProjectionCacheRdb.timers");
+	}
+	/** One fail-soft durable checkpoint. */
+	async flushSoft(session, trigger) {
+		try {
+			await this.write(session);
+		} catch (error) {
+			this.ctx.logger.warn(`session projection cache: ${trigger} write for "${session.id}" failed (cache stays stale): ${String(error)}`);
+		}
+	}
+	/** Reset one session's dirty bookkeeping (its checkpoint is being written). */
+	markClean(session) {
+		const state = this.dirty.get(session);
+		if (state === void 0) return;
+		state.pending = 0;
+		if (state.timer !== void 0) {
+			clearTimeout(state.timer);
+			state.timer = void 0;
+		}
+	}
+	/** Replace one session's stored record with its log identity and a detached snapshot of `rows`. */
+	async put(id, identity, rows) {
+		const detached = detachJson(rows);
+		await this.repository.putProjcache(id, detached);
+		if (!this.directReads) this.records.set(id, {
+			sessionId: id,
+			identity,
+			rows: detached
+		});
+	}
+};
+/** Detach one checkpoint from live unit state, refusing non-lossless JSON. */
+function detachJson(rows) {
+	let text;
+	try {
+		text = JSON.stringify(rows);
+	} catch (error) {
+		throw new TypeError(`projection checkpoint is not losslessly JSON-serializable: ${String(error)}`, { cause: error });
+	}
+	if (text === void 0) throw new TypeError("projection checkpoint is not losslessly JSON-serializable");
+	return JSON.parse(text);
+}
+/** Project a header onto the identity fields a record is bound to. */
+function identityOf(header, inheritedEventCount) {
+	const cut = SessionLogOffset(inheritedEventCount);
+	if (!header.isSeeded && cut !== 0) throw new Error("unseeded projection-cache identity inherited event count must be 0");
+	return {
+		formatVersion: header.version,
+		createdAt: header.createdAt,
+		...header.cwd === void 0 ? {} : { cwd: header.cwd },
+		isSeeded: header.isSeeded,
+		inheritedEventCount: cut
+	};
+}
+/**
+* Whether a stored record's bound identity names the caller's lifecycle.
+* An absent format generation cannot prove the fold semantics and never
+* matches. Once the format matches, absent lineage fields (records admitted
+* via compatible versions predate them) read as the unseeded lineage.
+*/
+function identityMatches(stored, expected) {
+	return stored.formatVersion === expected.formatVersion && lifecycleIdentityMatches(stored, expected);
+}
+/** Match one predecessor cache record to the authoritative listed lifecycle. */
+function predecessorIdentityMatches(stored, expected) {
+	return (stored.formatVersion === void 0 || stored.formatVersion < expected.formatVersion) && lifecycleIdentityMatches(stored, expected);
+}
+/** Match the format-independent fields that distinguish one Session lifecycle. */
+function lifecycleIdentityMatches(stored, expected) {
+	return stored.createdAt === expected.createdAt && stored.cwd === expected.cwd && (stored.isSeeded ?? false) === expected.isSeeded && (stored.inheritedEventCount ?? 0) === expected.inheritedEventCount;
+}
+//#endregion
+//#region src/storage-takeover/storage-backend.ts
+/**
+* storages 接管：注册在 storage hub 上的 `rdb` KV 后端。它把 workspace 域
+* （上游 single 布局：一张 `workspaces` 表 + global 单例）映射到 session-rdb
+* 的语义专用表，与事件日志同库同连接；域层（`ctx.storageDomain`）通过
+* `routes` 把 `workspace` 域路由到本后端。
+*
+* 本后端只服务已知域的专用表：未知 unit 名 fail loud，而不是静默落到通用
+* 存储——表结构是显式维护的（见 docs/schema.md）。
+*/
+/** 本后端唯一服务的域：上游 `workspaceDomainSpec`（v2，single 布局）。 */
+const WORKSPACE_UNIT = "workspace";
+const WORKSPACE_TABLE = "workspaces";
+/** 只服务 workspace 域的 KV 后端。 */
+var RdbStorageBackend = class {
+	repository;
+	kv = { open: (descriptor) => this.openUnit(descriptor) };
+	/** 已打开（或打开中）的 unit 名；重复 open 是调用方 bug。 */
+	open = /* @__PURE__ */ new Set();
+	closed = false;
+	/**
+	* @param repository - storages 接管表访问层（与事件日志同介质）。
+	*/
+	constructor(repository) {
+		this.repository = repository;
+	}
+	async openUnit(descriptor) {
+		if (this.closed) throw new StorageError("closed", "rdb storage backend is closed");
+		if (descriptor.name !== WORKSPACE_UNIT) throw new Error(`rdb storage backend serves only the '${WORKSPACE_UNIT}' domain (requested '${descriptor.name}')`);
+		if (!descriptor.tables.includes(WORKSPACE_TABLE) || descriptor.hasGlobal !== true) throw new Error(`rdb storage backend expects the '${WORKSPACE_UNIT}' domain shape (table '${WORKSPACE_TABLE}' plus a global slot)`);
+		if (this.open.has(descriptor.name)) throw new Error(`kv unit '${descriptor.name}' is already open (double-open is a caller bug)`);
+		const stored = await this.repository.readUnitVersion(descriptor.name);
+		if (stored === void 0) await this.repository.insertUnitVersion(descriptor.name, descriptor.version);
+		else if (stored !== descriptor.version) throw new StorageError("version-mismatch", `kv unit '${descriptor.name}' is stamped version ${stored} on the medium, incompatible with descriptor version ${descriptor.version}`);
+		this.open.add(descriptor.name);
+		return new WorkspaceKvUnit(this.repository, descriptor, () => {
+			this.open.delete(descriptor.name);
+		});
+	}
+	/**
+	* Release the backend. The medium (the session database) belongs to the
+	* owning session-rdb plugin, so closing open units here does not close it.
+	* @returns resolution after the name table is cleared.
+	*/
+	async close() {
+		this.closed = true;
+		this.open.clear();
+	}
+};
+/** workspace 域的 KV unit：每个原语一条 SQL 语句，值形状与上游记录一致。 */
+var WorkspaceKvUnit = class {
+	repository;
+	descriptor;
+	onClose;
+	closed = false;
+	constructor(repository, descriptor, onClose) {
+		this.repository = repository;
+		this.descriptor = descriptor;
+		this.onClose = onClose;
+	}
+	async loadAll() {
+		this.assertOpen();
+		const records = Object.create(null);
+		for (const { id, record } of await this.repository.listWorkspaces()) records[id] = record;
+		const state = await this.repository.readWorkspaceState();
+		return {
+			tables: { [WORKSPACE_TABLE]: records },
+			global: state
+		};
+	}
+	async putRecord(table, key, value) {
+		this.assertOpen();
+		this.assertTable(table);
+		await this.repository.putWorkspace(key, workspaceRecordOf(value));
+	}
+	async deleteRecord(table, key) {
+		this.assertOpen();
+		this.assertTable(table);
+		await this.repository.deleteWorkspace(key);
+	}
+	async setGlobal(value) {
+		this.assertOpen();
+		await this.repository.writeWorkspaceState(workspaceStateOf(value));
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.onClose();
+	}
+	assertOpen() {
+		if (this.closed) throw new StorageError("closed", `kv unit '${this.descriptor.name}' is closed`);
+	}
+	assertTable(table) {
+		if (table !== WORKSPACE_TABLE) throw new Error(`unit '${this.descriptor.name}' does not declare table '${table}'`);
+	}
+};
+/** Narrow one opaque KV record to the workspace record the domain shipped. */
+function workspaceRecordOf(value) {
+	const record = value;
+	if (typeof record !== "object" || record === null || typeof record.path !== "string" || typeof record.title !== "string" || !Array.isArray(record.sessionIds) || typeof record.createdAt !== "string" || typeof record.updatedAt !== "string") throw new TypeError("workspace record does not match the stored shape");
+	return {
+		path: record.path,
+		title: record.title,
+		sessionIds: record.sessionIds.map((id) => id),
+		createdAt: record.createdAt,
+		updatedAt: record.updatedAt
+	};
+}
+/** Narrow one opaque KV global to the workspace registry state the domain shipped. */
+function workspaceStateOf(value) {
+	const state = value;
+	if (typeof state !== "object" || state === null || typeof state.initialized !== "boolean" || !Array.isArray(state.workspaceIds) || !Array.isArray(state.archivedSessionIds)) throw new TypeError("workspace registry state does not match the stored shape");
+	return {
+		initialized: state.initialized,
+		workspaceIds: state.workspaceIds.map((id) => id),
+		archivedSessionIds: state.archivedSessionIds.map((id) => id),
+		...state.pendingMutation === void 0 ? {} : { pendingMutation: state.pendingMutation }
+	};
+}
+//#endregion
+//#region src/storage-takeover/index.ts
+/**
+* Install the storages takeover on the session-rdb plugin context.
+* @param ctx - session-rdb plugin context.
+* @param options - repository and projection-cache throttle parameters.
+*/
+function installStorageTakeover(ctx, options) {
+	ctx.inject(["storage"], (storageCtx) => {
+		const backend = new RdbStorageBackend(options.repository);
+		storageCtx.effect(() => {
+			const unregister = storageCtx.storage.backend.register("rdb", backend);
+			return async () => {
+				unregister();
+				await backend.close();
+			};
+		}, "session-rdb.storageBackend");
+		storageCtx.provide(storageBackendServiceKey("rdb"), backend);
+	});
+	ctx.inject(["sessionProjections"], (projectionCtx) => {
+		new SessionProjectionCacheRdb(projectionCtx, options.projectionCache, options.repository, options.ready);
+	});
+}
+//#endregion
 //#region src/index.ts
+/** 投影缓存默认写节流（与上游 base 装配的部署值一致）。 */
+const DEFAULT_PROJECTION_WRITE_EVERY_EVENTS = 200;
+const DEFAULT_PROJECTION_WRITE_INTERVAL_MS = 5e3;
 /** 会话级写所有权与 live 路由簿记。 */
 var RdbBackendTracker = class {
 	name;
@@ -519,11 +999,25 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			"truncate",
 			"persist"
 		]).default("wal"),
-		busyTimeout: z.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS)
+		busyTimeout: z.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS),
+		projectionCache: z.object({
+			writeEveryEvents: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
+			writeIntervalMs: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
+		}).default({
+			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
+			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
+		})
 	}), z.object({
 		type: z.const("postgres"),
 		connectionString: z.string().required(),
-		schema: z.string().default("public")
+		schema: z.string().default("public"),
+		projectionCache: z.object({
+			writeEveryEvents: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_EVERY_EVENTS),
+			writeIntervalMs: z.natural().min(1).default(DEFAULT_PROJECTION_WRITE_INTERVAL_MS)
+		}).default({
+			writeEveryEvents: DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
+			writeIntervalMs: DEFAULT_PROJECTION_WRITE_INTERVAL_MS
+		})
 	})]);
 	static settingsNs = "session-rdb";
 	name = "session-rdb";
@@ -554,6 +1048,14 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		this.installLiveRouting(ctx);
 		new SessionBranchRdb(this.ctx);
 		registerSessionImport(this.ctx, this);
+		installStorageTakeover(this.ctx, {
+			repository: this.backend.storage,
+			ready: this.ready,
+			projectionCache: {
+				writeEveryEvents: this.config.projectionCache?.writeEveryEvents ?? DEFAULT_PROJECTION_WRITE_EVERY_EVENTS,
+				writeIntervalMs: this.config.projectionCache?.writeIntervalMs ?? DEFAULT_PROJECTION_WRITE_INTERVAL_MS
+			}
+		});
 	}
 	async init() {
 		await this.backend.open();
@@ -1064,6 +1566,7 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 	}
 	if (eventRows.length > 0) await tx.insertEvents(eventRows);
 	await tx.insertBridges(bridgeRows);
+	if (events.some((event) => event.type === "session/title")) await tx.refreshTitle(meta.id);
 	return {
 		headEventId: parentId,
 		headSequence: nextSeq - 1

package/dist/{log-BIuXv09P.mjs → log-DO69NQnn.mjs}

@@ -513,5 +513,20 @@ function toJsonlArtifact(meta, inheritedEventCount, events) {
 	for (const event of events) lines.push(JSON.stringify(sessionFormatCatalog.encodeCurrentEvent(event)));
 	return lines.join("\n");
 }
+/**
+* 事件行 JSON → `session/title` 的标题文本。存储层写路径保证 `f_data` 是完整
+* 事件 JSON；形状不符（或损坏）按「无标题」处理——标题是派生显示数据。
+* @param data - `t_events.f_data` 原文。
+* @returns 标题文本，或 `undefined`。
+*/
+function titleOfEventData(data) {
+	try {
+		const value = JSON.parse(data);
+		const title = value.data?.title ?? value.title;
+		return typeof title === "string" ? title : void 0;
+	} catch {
+		return;
+	}
+}
 //#endregion
-export { repairAssistantSettlement as a, repairRequestHeaders as c, rowToMeta as d, scanRows as f, toJsonlArtifact as g, syncMeteringRanges as h, renameLegacyPtcEvents as i, repairSurfaceOps as l, sessionInsertRow as m, orphanInboxSpliceSeqs as n, repairOrphanInboxSplices as o, sessionConflictRow as p, recomputeReplaceProvenance as r, repairReadView as s, findSurfaceRepairs as t, rowToEvent as u };
+export { toJsonlArtifact as _, repairAssistantSettlement as a, repairRequestHeaders as c, rowToMeta as d, scanRows as f, titleOfEventData as g, syncMeteringRanges as h, renameLegacyPtcEvents as i, repairSurfaceOps as l, sessionInsertRow as m, orphanInboxSpliceSeqs as n, repairOrphanInboxSplices as o, sessionConflictRow as p, recomputeReplaceProvenance as r, repairReadView as s, findSurfaceRepairs as t, rowToEvent as u };