@morlay/session-rdb 0.0.16-alpha.4 → 0.0.17

package/dist/{sqlite-IH5I48aL.mjs → sqlite-BIPdMNQb.mjs}

@@ -1,6 +1,7 @@
-import { m as sessionInsertRow, p as sessionConflictRow } from "./log-BIuXv09P.mjs";
+import { g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow } from "./log-DO69NQnn.mjs";
 import { randomUUID } from "node:crypto";
-import { and, eq, gte, sql } from "drizzle-orm";
+import { SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
+import { and, desc, eq, gte, isNotNull, notInArray, sql } from "drizzle-orm";
 import { check, index, integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
 import { bigint, check as check$1, index as index$1, integer as integer$1, pgSchema, pgTable, serial, text as text$1, unique as unique$1 } from "drizzle-orm/pg-core";
 import { readdirSync, statSync } from "node:fs";
@@ -196,7 +197,13 @@ const sessions = {
 		f_revision: {
 			type: "integer",
 			notNull: true
-		}
+		},
+		/** 归档标记：非空即该会话已归档（毫秒时间戳），NULL 表示未归档。 */
+		f_archived_at: { type: "bigint" },
+		/** 最新会话标题（最后一条 `session/title` 事件的 title），NULL 表示尚无标题。 */
+		f_title: { type: "text" },
+		/** `f_title` 来源事件的稠密 seq（列表 hint 的水位）。 */
+		f_title_seq: { type: "integer" }
 	}
 };
 //#endregion
@@ -302,20 +309,193 @@ const sessionEvents$1 = {
 	indexes: { idx_session_events_event_id: { columns: ["f_event_id"] } }
 };
 //#endregion
+//#region src/entities/v3/storage-units.ts
+/** storage 域版本账本：域首次打开时写入 descriptor version，其后按 accepted 集合校验。 */
+const storageUnits = {
+	name: "t_storage_units",
+	columns: {
+		f_name: {
+			type: "text",
+			primaryKey: true
+		},
+		f_version: {
+			type: "integer",
+			notNull: true
+		}
+	}
+};
+//#endregion
+//#region src/entities/v3/workspaces.ts
+/**
+* workspace 域记录表（上游 `workspace` 域 v2 的 `workspaces` 表）：
+* 记录本身拆成语义列；会话归属在 {@link workspaceSessions}（带顺序），
+* 显示顺序由 `f_position` 承载（未进入 `workspaceIds` 的记录为 -1）。
+*/
+const workspaces = {
+	name: "t_workspaces",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_workspace_id: {
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		f_path: {
+			type: "text",
+			notNull: true
+		},
+		f_title: {
+			type: "text",
+			notNull: true
+		},
+		f_created_at: {
+			type: "text",
+			notNull: true
+		},
+		f_updated_at: {
+			type: "text",
+			notNull: true
+		},
+		f_position: {
+			type: "integer",
+			notNull: true,
+			default: -1
+		}
+	}
+};
+//#endregion
+//#region src/entities/v3/workspace-sessions.ts
+/**
+* workspace 的会话归属（上游 `workspaceRecord.sessionIds` 的数组顺序）：
+* 一个会话一行，`f_position` 是归属显示顺序。会话 id 有独立索引，可按
+* session 反查归属 workspace。
+*/
+const workspaceSessions = {
+	name: "t_workspace_sessions",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_workspace_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_workspaces",
+				column: "f_workspace_id",
+				onDelete: "cascade"
+			}
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true
+		},
+		f_position: {
+			type: "integer",
+			notNull: true
+		}
+	},
+	uniques: { uq_workspace_sessions_workspace_session: { columns: ["f_workspace_id", "f_session_id"] } },
+	indexes: { idx_workspace_sessions_session_id: { columns: ["f_session_id"] } }
+};
+//#endregion
+//#region src/entities/v3/workspace-state.ts
+/**
+* workspace 域 global 单例（上游 `workspaceDomainState`）：`initialized` 是
+* 引导标记，`pendingMutation` 拆成操作与目标两列（create / delete 的可恢复
+* 两写标记）。显示顺序（`workspaceIds`）在 `t_workspaces.f_position`，
+* 归档集在 `t_session_archives`。
+*/
+const workspaceState = {
+	name: "t_workspace_state",
+	columns: {
+		f_singleton: {
+			type: "integer",
+			primaryKey: true
+		},
+		f_initialized: {
+			type: "integer",
+			notNull: true
+		},
+		f_pending_operation: { type: "text" },
+		f_pending_workspace_id: { type: "text" }
+	},
+	checks: { ck_workspace_state_singleton: { expression: "f_singleton = 1" } }
+};
+//#endregion
+//#region src/entities/v3/session-projcache-rows.ts
+/**
+* 投影 checkpoint 行（上游 checkpoint 的 `(sessionId, key, ver, seq, val)`
+* 逐行落库）：`f_seq` 是该行的日志水位、`f_ver` 是投影单元的 stateVersion。
+* 行是折出捷径、非权威，版本不匹配时整行丢弃。
+*
+* checkpoint 的日志 identity 不另存一份：它与 `t_sessions` 的行是 1:1，直接
+* 复用该行的 `f_version` / `f_created_at` / `f_cwd` / `f_seed_length` 做校验。
+*/
+const sessionProjcacheRows = {
+	name: "t_session_projcache_row",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		f_key: {
+			type: "text",
+			notNull: true
+		},
+		f_ver: {
+			type: "integer",
+			notNull: true
+		},
+		f_seq: {
+			type: "integer",
+			notNull: true
+		},
+		f_val: {
+			type: "text",
+			notNull: true
+		}
+	},
+	uniques: { uq_session_projcache_row_session_key: { columns: ["f_session_id", "f_key"] } },
+	indexes: { idx_session_projcache_row_key: { columns: ["f_key"] } }
+};
+//#endregion
 //#region src/entities/v3/index.ts
 const sqliteTableDefs = [
 	persistenceState,
 	schemaMeta,
 	sessions,
 	events,
-	sessionEvents$1
+	sessionEvents$1,
+	storageUnits,
+	workspaces,
+	workspaceSessions,
+	workspaceState,
+	sessionProjcacheRows
 ];
 const postgresTableDefs = [
 	persistenceState,
 	schemaMeta,
 	sessions,
 	events,
-	sessionEvents$1
+	sessionEvents$1,
+	storageUnits,
+	workspaces,
+	workspaceSessions,
+	workspaceState,
+	sessionProjcacheRows
 ];
 ({ ...sessionEvents$1 }), { ...sessionEvents$1.columns };
 //#endregion
@@ -329,6 +509,11 @@ const tSchemaMeta = sqliteTables["t_schema_meta"];
 const tSessions = sqliteTables["t_sessions"];
 const tEvents = sqliteTables["t_events"];
 const tSessionEvents = sqliteTables["t_session_events"];
+const tStorageUnits = sqliteTables["t_storage_units"];
+const tWorkspaces = sqliteTables["t_workspaces"];
+const tWorkspaceSessions = sqliteTables["t_workspace_sessions"];
+const tWorkspaceState = sqliteTables["t_workspace_state"];
+const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"];
 const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
 function eventKind(event) {
 	switch (event.type) {
@@ -343,6 +528,8 @@ function eventKind(event) {
 		case "session/end-seed": return "turn";
 		case "tool/call":
 		case "tool/result":
+		case "tool/ptc-dispatch-start":
+		case "tool/ptc-dispatch":
 		case "tool/code-dispatch-start":
 		case "tool/code-dispatch": return "tool";
 		case "request/header":
@@ -416,6 +603,8 @@ function eventDimensions(event) {
 			name: typeof data["name"] === "string" ? data["name"] : "",
 			actionId: typeof data["callId"] === "string" ? data["callId"] : ""
 		};
+		case "tool/ptc-dispatch-start":
+		case "tool/ptc-dispatch":
 		case "tool/code-dispatch-start":
 		case "tool/code-dispatch": return {
 			kind,
@@ -481,6 +670,254 @@ function eventDimensions(event) {
 	}
 }
 //#endregion
+//#region src/storage-takeover/repository.ts
+/**
+* storages 接管表的方言无关实现：SQLite 与 PostgreSQL 的 drizzle 查询构建器
+* 共享同一套调用形状（SQLite 走同步 `.all()`/`.get()`/`.run()`，PostgreSQL
+* 走 thenable），差别由本模块的执行 helper 吸收。
+*
+* workspace 域是权威数据：记录、归属、显示顺序与归档集都拆成语义表，每次写入
+* 在介质事务内完成（`host.writeAtomically`），不留部分应用的中间态。
+*/
+/** 多行查询：SQLite 同步 `.all()`，PostgreSQL await。 */
+async function allRows(query) {
+	const q = query;
+	if (typeof q.all === "function") return q.all();
+	return await query;
+}
+/** 单行查询：SQLite 同步 `.get()`，PostgreSQL await 后取首行。 */
+async function oneRow(query) {
+	const q = query;
+	if (typeof q.get === "function") return q.get();
+	return (await query)[0];
+}
+/** 写入语句：SQLite 同步 `.run()`，PostgreSQL await。 */
+async function runQuery(query) {
+	const q = query;
+	if (typeof q.run === "function") {
+		q.run();
+		return;
+	}
+	await query;
+}
+/** 一行会话元数据 → 上游 `CheckpointIdentity`。 */
+function identityOfSession(row) {
+	return {
+		formatVersion: row.fVersion,
+		createdAt: row.fCreatedAt,
+		...row.fCwd === null ? {} : { cwd: row.fCwd },
+		isSeeded: row.fSeedLength !== null,
+		...row.fSeedLength === null ? {} : { inheritedEventCount: SessionLogOffset(row.fSeedLength) }
+	};
+}
+/** 存储的整数水位 → 上游 seq cursor（-1 是空日志哨兵）。 */
+function seqCursor(seq) {
+	return seq === -1 ? -1 : SessionSeq(seq);
+}
+/** 两写标记的两列 → 上游 `pendingMutation`（未知操作按缺失处理）。 */
+function pendingMutationOf(row) {
+	const operation = row.fPendingOperation;
+	if (operation !== "create" && operation !== "delete") return void 0;
+	return {
+		operation,
+		workspaceId: row.fPendingWorkspaceId ?? ""
+	};
+}
+/**
+* 构建一个介质的 storages 接管访问层。
+* @param host - 介质句柄、方言表对象与事务执行器。
+* @returns 方言无关的访问层。
+*/
+function createStorageRepository(host) {
+	const tables = host.tables;
+	const tUnits = tables["t_storage_units"];
+	const tSessions = tables["t_sessions"];
+	const tWorkspaces = tables["t_workspaces"];
+	const tWorkspaceSessions = tables["t_workspace_sessions"];
+	const tWorkspaceState = tables["t_workspace_state"];
+	const tProjcacheRows = tables["t_session_projcache_row"];
+	/** checkpoint identity 的列投影：直接复用会话行，不再单存记录头。 */
+	const sessionIdentity = {
+		fSessionId: tSessions.fSessionId,
+		fVersion: tSessions.fVersion,
+		fCreatedAt: tSessions.fCreatedAt,
+		fCwd: tSessions.fCwd,
+		fSeedLength: tSessions.fSeedLength
+	};
+	const dbx = async () => await host.db();
+	return {
+		async readUnitVersion(name) {
+			return (await oneRow((await dbx()).select().from(tUnits).where(eq(tUnits.fName, name))))?.fVersion;
+		},
+		async insertUnitVersion(name, version) {
+			await runQuery((await dbx()).insert(tUnits).values({
+				fName: name,
+				fVersion: version
+			}).onConflictDoNothing());
+		},
+		async listWorkspaces() {
+			const db = await dbx();
+			const rows = await allRows(db.select().from(tWorkspaces));
+			const links = await allRows(db.select().from(tWorkspaceSessions));
+			const sessions = /* @__PURE__ */ new Map();
+			for (const link of links) {
+				const owned = sessions.get(link.fWorkspaceId) ?? [];
+				owned.push({
+					id: link.fSessionId,
+					position: link.fPosition
+				});
+				sessions.set(link.fWorkspaceId, owned);
+			}
+			return rows.map((row) => ({
+				id: row.fWorkspaceId,
+				record: {
+					path: row.fPath,
+					title: row.fTitle,
+					sessionIds: (sessions.get(row.fWorkspaceId) ?? []).sort((left, right) => left.position - right.position).map((entry) => SessionId(entry.id)),
+					createdAt: row.fCreatedAt,
+					updatedAt: row.fUpdatedAt
+				}
+			}));
+		},
+		async putWorkspace(id, record) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				const values = {
+					fWorkspaceId: id,
+					fPath: record.path,
+					fTitle: record.title,
+					fCreatedAt: record.createdAt,
+					fUpdatedAt: record.updatedAt
+				};
+				await runQuery(db.insert(tWorkspaces).values(values).onConflictDoUpdate({
+					target: tWorkspaces.fWorkspaceId,
+					set: values
+				}));
+				await runQuery(db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fWorkspaceId, id)));
+				const links = record.sessionIds.map((sessionId, position) => ({
+					fWorkspaceId: id,
+					fSessionId: sessionId,
+					fPosition: position
+				}));
+				if (links.length > 0) await runQuery(db.insert(tWorkspaceSessions).values(links));
+			});
+		},
+		async deleteWorkspace(id) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				await runQuery(db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fWorkspaceId, id)));
+				await runQuery(db.delete(tWorkspaces).where(eq(tWorkspaces.fWorkspaceId, id)));
+			});
+		},
+		async readWorkspaceState() {
+			const db = await dbx();
+			const row = await oneRow(db.select().from(tWorkspaceState).where(eq(tWorkspaceState.fSingleton, 1)));
+			if (row === void 0) return null;
+			const ordered = await allRows(db.select().from(tWorkspaces).where(gte(tWorkspaces.fPosition, 0)).orderBy(tWorkspaces.fPosition));
+			const archives = await allRows(db.select({ fSessionId: tSessions.fSessionId }).from(tSessions).where(isNotNull(tSessions.fArchivedAt)).orderBy(tSessions.fArchivedAt));
+			const pendingMutation = pendingMutationOf(row);
+			return {
+				initialized: row.fInitialized !== 0,
+				workspaceIds: ordered.map((entry) => entry.fWorkspaceId),
+				archivedSessionIds: archives.map((entry) => entry.fSessionId),
+				...pendingMutation === void 0 ? {} : { pendingMutation }
+			};
+		},
+		async writeWorkspaceState(state) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				const pending = state.pendingMutation;
+				const values = {
+					fSingleton: 1,
+					fInitialized: state.initialized ? 1 : 0,
+					fPendingOperation: pending === void 0 || typeof pending.operation !== "string" ? null : pending.operation,
+					fPendingWorkspaceId: pending === void 0 || typeof pending.workspaceId !== "string" ? null : pending.workspaceId
+				};
+				await runQuery(db.insert(tWorkspaceState).values(values).onConflictDoUpdate({
+					target: tWorkspaceState.fSingleton,
+					set: values
+				}));
+				await runQuery(db.update(tWorkspaces).set({ fPosition: -1 }));
+				for (const [position, workspaceId] of state.workspaceIds.entries()) await runQuery(db.update(tWorkspaces).set({ fPosition: position }).where(eq(tWorkspaces.fWorkspaceId, workspaceId)));
+				const archived = state.archivedSessionIds;
+				await runQuery(archived.length === 0 ? db.update(tSessions).set({ fArchivedAt: null }).where(isNotNull(tSessions.fArchivedAt)) : db.update(tSessions).set({ fArchivedAt: null }).where(and(isNotNull(tSessions.fArchivedAt), notInArray(tSessions.fSessionId, archived))));
+				const stamp = Date.now();
+				for (const sessionId of archived) await runQuery(db.update(tSessions).set({ fArchivedAt: sql`COALESCE(${tSessions.fArchivedAt}, ${stamp})` }).where(eq(tSessions.fSessionId, sessionId)));
+			});
+		},
+		async loadProjcache() {
+			const db = await dbx();
+			const rows = await allRows(db.select().from(tProjcacheRows));
+			if (rows.length === 0) return [];
+			const sessions = await allRows(db.select(sessionIdentity).from(tSessions));
+			const entries = /* @__PURE__ */ new Map();
+			for (const session of sessions) entries.set(session.fSessionId, {
+				sessionId: SessionId(session.fSessionId),
+				identity: identityOfSession(session),
+				rows: {}
+			});
+			for (const row of rows) {
+				const entry = entries.get(row.fSessionId);
+				if (entry === void 0) continue;
+				entry.rows[row.fKey] = {
+					ver: row.fVer,
+					seq: seqCursor(row.fSeq),
+					val: JSON.parse(row.fVal)
+				};
+			}
+			return [...entries.values()].filter((entry) => Object.keys(entry.rows).length > 0);
+		},
+		async putProjcache(sessionId, rows) {
+			await host.writeAtomically(async () => {
+				const db = await dbx();
+				await runQuery(db.delete(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)));
+				const values = Object.entries(rows).map(([key, row]) => ({
+					fSessionId: sessionId,
+					fKey: key,
+					fVer: row.ver,
+					fSeq: row.seq,
+					fVal: JSON.stringify(row.val)
+				}));
+				if (values.length > 0) await runQuery(db.insert(tProjcacheRows).values(values));
+			});
+		},
+		async deleteProjcache(sessionId) {
+			await runQuery((await dbx()).delete(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)));
+		},
+		...host.dbSync === void 0 ? {} : {
+			readProjcacheSync: (sessionId) => {
+				const db = host.dbSync();
+				const stored = db.select().from(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)).all();
+				if (stored.length === 0) return void 0;
+				const session = db.select(sessionIdentity).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
+				if (session === void 0) return void 0;
+				const rows = {};
+				for (const row of stored) rows[row.fKey] = {
+					ver: row.fVer,
+					seq: seqCursor(row.fSeq),
+					val: JSON.parse(row.fVal)
+				};
+				return {
+					sessionId: SessionId(sessionId),
+					identity: identityOfSession(session),
+					rows
+				};
+			},
+			readSessionTitleSync: (sessionId) => {
+				const row = host.dbSync().select({
+					fTitle: tSessions.fTitle,
+					fTitleSeq: tSessions.fTitleSeq
+				}).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
+				if (row === void 0 || row.fTitle === null || row.fTitleSeq === null) return void 0;
+				return {
+					title: row.fTitle,
+					seq: row.fTitleSeq
+				};
+			}
+		}
+	};
+}
+//#endregion
 //#region src/sqlite.ts
 /** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
 const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
@@ -555,12 +992,60 @@ var SqliteBackend = class SqliteBackend {
 	options;
 	kind = "sqlite";
 	storeIdentity;
+	/** storages 接管表访问层；句柄在 open() 完成后解析。 */
+	storage;
 	dbPath = "";
 	db;
+	dbReady;
+	resolveDb;
+	rejectDb;
 	constructor(options) {
 		this.options = options;
+		this.dbReady = new Promise((resolve, reject) => {
+			this.resolveDb = resolve;
+			this.rejectDb = reject;
+		});
+		this.dbReady.catch(() => {});
+		this.storage = createStorageRepository({
+			db: () => this.dbReady,
+			dbSync: () => {
+				if (this.db === void 0) throw new Error("sqlite session database is not open");
+				return this.db;
+			},
+			writeAtomically: (fn) => enqueueSqliteTx(this.dbPath, async () => {
+				const db = await this.dbReady;
+				db.$client.exec("BEGIN IMMEDIATE");
+				try {
+					const result = await fn();
+					db.$client.exec("COMMIT");
+					return result;
+				} catch (error) {
+					try {
+						db.$client.exec("ROLLBACK");
+					} catch {}
+					throw error;
+				}
+			}),
+			tables: {
+				t_sessions: tSessions,
+				t_storage_units: tStorageUnits,
+				t_workspaces: tWorkspaces,
+				t_workspace_sessions: tWorkspaceSessions,
+				t_workspace_state: tWorkspaceState,
+				t_session_projcache_row: tSessionProjcacheRows
+			}
+		});
 	}
 	async open() {
+		try {
+			await this.doOpen();
+			this.resolveDb(this.db);
+		} catch (error) {
+			this.rejectDb(error);
+			throw error;
+		}
+	}
+	async doOpen() {
 		const actual = this.options.path === ":memory:" ? this.options.path : resolve(this.options.path);
 		this.dbPath = actual;
 		if (actual !== ":memory:") {
@@ -626,6 +1111,7 @@ var SqliteBackend = class SqliteBackend {
 		insertBridges: (rows) => this.insertBridges(rows),
 		updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
 		bumpRevision: (id) => this.bumpRevision(id),
+		refreshTitle: (id) => this.refreshTitle(id),
 		deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
 		getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence)
 	};
@@ -671,6 +1157,18 @@ var SqliteBackend = class SqliteBackend {
 	async bumpRevision(id) {
 		this.db.update(tSessions).set({ fRevision: sql`${tSessions.fRevision} + 1` }).where(eq(tSessions.fSessionId, id)).run();
 	}
+	/** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
+	async refreshTitle(id) {
+		const row = this.db.select({
+			fSequence: tSessionEvents.fSequence,
+			fData: tEvents.fData
+		}).from(tSessionEvents).innerJoin(tEvents, eq(tEvents.fEventId, tSessionEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), eq(tEvents.fType, "session/title"))).orderBy(desc(tSessionEvents.fSequence)).limit(1).get();
+		const title = row === void 0 ? void 0 : titleOfEventData(row.fData);
+		this.db.update(tSessions).set({
+			fTitle: title ?? null,
+			fTitleSeq: title === void 0 ? null : row.fSequence
+		}).where(eq(tSessions.fSessionId, id)).run();
+	}
 	async deleteBridgeTail(id, fromSequence) {
 		this.db.delete(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence))).run();
 	}
@@ -696,4 +1194,4 @@ var SqliteBackend = class SqliteBackend {
 	}
 };
 //#endregion
-export { SCHEMA_VERSION as a, eventKind as c, tSchemaMeta as d, tSessionEvents as f, WriteGuard as g, toPostgresSchema as h, EVENT_ENCODING as i, tEvents as l, postgresTableDefs as m, openDatabase as n, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as o, tSessions as p, DEFAULT_BUSY_TIMEOUT_MS as r, eventDimensions as s, SqliteBackend as t, tPersistenceState as u };
+export { WriteGuard as S, tWorkspaceSessions as _, EVENT_ENCODING as a, postgresTableDefs as b, eventDimensions as c, tPersistenceState as d, tSchemaMeta as f, tStorageUnits as g, tSessions as h, DEFAULT_BUSY_TIMEOUT_MS as i, eventKind as l, tSessionProjcacheRows as m, openDatabase as n, SCHEMA_VERSION as o, tSessionEvents as p, createStorageRepository as r, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as s, SqliteBackend as t, tEvents as u, tWorkspaceState as v, toPostgresSchema as x, tWorkspaces as y };

package/dist/storage.d.mts

@@ -1,4 +1,4 @@
-import { _ as BackendTx, a as JournalMode, c as eventDimensions, d as tPersistenceState, f as tSchemaMeta, g as Backend, h as WriteGuard, i as EventRole, l as eventKind, m as tSessions, n as EVENT_ENCODING, o as SCHEMA_VERSION, p as tSessionEvents, r as EventKind, s as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as DEFAULT_BUSY_TIMEOUT_MS, u as tEvents, v as EventRow, y as SessionRow } from "./schema-COK7-wRV.mjs";
+import { C as EventRow, S as BackendTx, T as StorageRepository, _ as tWorkspaceSessions, a as JournalMode, b as WriteGuard, c as eventDimensions, d as tPersistenceState, f as tSchemaMeta, g as tStorageUnits, h as tSessions, i as EventRole, l as eventKind, m as tSessionProjcacheRows, n as EVENT_ENCODING, o as SCHEMA_VERSION, p as tSessionEvents, r as EventKind, s as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as DEFAULT_BUSY_TIMEOUT_MS, u as tEvents, v as tWorkspaceState, w as SessionRow, x as Backend, y as tWorkspaces } from "./schema-Bo6Hy5gW.mjs";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { DatabaseSync } from "node:sqlite";
 //#region src/sqlite.d.ts
@@ -12,10 +12,16 @@ declare class SqliteBackend implements Backend {
   private readonly options;
   readonly kind: "sqlite";
   storeIdentity: string;
+  /** storages 接管表访问层；句柄在 open() 完成后解析。 */
+  readonly storage: StorageRepository;
   private dbPath;
   private db;
+  private readonly dbReady;
+  private resolveDb;
+  private rejectDb;
   constructor(options: SqliteBackendOptions);
   open(): Promise<void>;
+  private doOpen;
   close(): Promise<void>;
   getSession(id: SessionId): Promise<SessionRow | undefined>;
   getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
@@ -31,9 +37,11 @@ declare class SqliteBackend implements Backend {
   private insertBridges;
   private updateHead;
   private bumpRevision;
+  /** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
+  private refreshTitle;
   private deleteBridgeTail;
   private getPrevBridge;
   private eventRows;
 }
 //#endregion
-export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, EventKind, EventRole, type EventRow, JournalMode, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, type SessionRow, SqliteBackend, SqliteBackendOptions, WriteGuard, eventDimensions, eventKind, openDatabase, tEvents, tPersistenceState, tSchemaMeta, tSessionEvents, tSessions };
+export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, EventKind, EventRole, type EventRow, JournalMode, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, type SessionRow, SqliteBackend, SqliteBackendOptions, WriteGuard, eventDimensions, eventKind, openDatabase, tEvents, tPersistenceState, tSchemaMeta, tSessionEvents, tSessionProjcacheRows, tSessions, tStorageUnits, tWorkspaceSessions, tWorkspaceState, tWorkspaces };

package/dist/storage.mjs

@@ -1,2 +1,2 @@
-import { a as SCHEMA_VERSION, c as eventKind, d as tSchemaMeta, f as tSessionEvents, g as WriteGuard, i as EVENT_ENCODING, l as tEvents, n as openDatabase, o as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, p as tSessions, r as DEFAULT_BUSY_TIMEOUT_MS, s as eventDimensions, t as SqliteBackend, u as tPersistenceState } from "./sqlite-IH5I48aL.mjs";
-export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, SqliteBackend, WriteGuard, eventDimensions, eventKind, openDatabase, tEvents, tPersistenceState, tSchemaMeta, tSessionEvents, tSessions };
+import { S as WriteGuard, _ as tWorkspaceSessions, a as EVENT_ENCODING, c as eventDimensions, d as tPersistenceState, f as tSchemaMeta, g as tStorageUnits, h as tSessions, i as DEFAULT_BUSY_TIMEOUT_MS, l as eventKind, m as tSessionProjcacheRows, n as openDatabase, o as SCHEMA_VERSION, p as tSessionEvents, s as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, t as SqliteBackend, u as tEvents, v as tWorkspaceState, y as tWorkspaces } from "./sqlite-BIPdMNQb.mjs";
+export { DEFAULT_BUSY_TIMEOUT_MS, EVENT_ENCODING, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, SqliteBackend, WriteGuard, eventDimensions, eventKind, openDatabase, tEvents, tPersistenceState, tSchemaMeta, tSessionEvents, tSessionProjcacheRows, tSessions, tStorageUnits, tWorkspaceSessions, tWorkspaceState, tWorkspaces };

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
 import { SessionPersistence } from "@deepseek-ai/dsh-session-persistence";
 import { Session, SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
-import { SettingsNamespace, SettingsProvider } from "@deepseek-ai/dsh-settings";
 import { Context, Fiber } from "@deepseek-ai/cordis";
+import { SettingsNamespace, SettingsProvider } from "@deepseek-ai/dsh-settings";
 //#region src/testing/helpers.d.ts
 declare class EmptySettings extends SettingsProvider {
   constructor(ctx: Context);

package/dist/testing.mjs

@@ -1,8 +1,8 @@
 import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionFormatUnsupportedError, SessionHandleClosedError, SessionPersistenceNotFoundError, SessionReadOnlyError } from "@deepseek-ai/dsh-session-persistence";
 import SessionStore, { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
+import { Context } from "@deepseek-ai/cordis";
 import { SettingsProvider } from "@deepseek-ai/dsh-settings";
 import { MessageId, createUserMessage, freezeMessage } from "@deepseek-ai/dsh-llm";
-import { Context } from "@deepseek-ai/cordis";
 //#region src/testing/helpers.ts
 var EmptySettings = class extends SettingsProvider {
 	constructor(ctx) {