@morlay/session-rdb 0.0.20 → 0.0.21-alpha.0

package/dist/src-CWTWV7vx.mjs

@@ -0,0 +1,1904 @@
+import { C as WriteGuard, S as toPostgresSchema, a as EVENT_ENCODING, c as eventDimensions, i as DEFAULT_BUSY_TIMEOUT_MS, r as createStorageRepository, t as SqliteBackend, x as postgresTableDefs } from "./sqlite-fpvm5Dzs.mjs";
+import { _ as toJsonlArtifact, d as rowToMeta, f as scanRows, g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, s as repairReadView, v as usageRowOf } from "./log-CnYct2Dv.mjs";
+import { c as isLegacyVersion, o as adoptLegacyRows, s as convertLegacyRows, t as SessionBranchRdb } from "./branch-5JzX9rUq.mjs";
+import { registerSessionImport } from "./import.mjs";
+import z from "@deepseek-ai/schemastery";
+import { randomUUID } from "node:crypto";
+import { Pool } from "pg";
+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 { sessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
+import { and, desc, eq, gte, inArray, lt, notInArray, sql } from "drizzle-orm";
+import { readdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { balanceRewindPrefix } from "@morlay/session-branch";
+import { strToU8, zip } from "fflate";
+import { SessionQueryEngine, SessionQueryError } from "@deepseek-ai/dsh-session-query";
+import { StorageError, storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
+import { Service } from "@deepseek-ai/cordis";
+//#region src/postgres.ts
+const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
+/** pg 的 text 列窄化：非字符串（含 null）都不当作文本。 */
+function text(value) {
+	return typeof value === "string" ? value : null;
+}
+/** pg 的 count/sum 回落成字符串：统一转成有限数。 */
+function numeric(value) {
+	const parsed = typeof value === "number" ? value : Number(value ?? 0);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+/** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
+function totalsOfRow(row) {
+	return {
+		events: numeric(row["events"]),
+		inputTokens: numeric(row["input_tokens"]),
+		outputTokens: numeric(row["output_tokens"]),
+		cacheReadTokens: numeric(row["cache_read_tokens"]),
+		reasoningTokens: numeric(row["reasoning_tokens"]),
+		totalTokens: numeric(row["total_tokens"])
+	};
+}
+var PostgresBackend = class PostgresBackend {
+	db;
+	options;
+	kind = "postgres";
+	storeIdentity;
+	tables;
+	storage;
+	opened;
+	resolveOpened;
+	rejectOpened;
+	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;
+				}
+			}, { isolationLevel: "serializable" }),
+			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) {
+			if (await this.readMeta(this.db, "schema_version") === "2") await this.baselineV2();
+		}
+		await migrate(this.db, { migrationsFolder: postgresMigrationsDir });
+		await this.backfillEventUsage();
+		const storeId = await this.db.transaction(async (tx) => {
+			await tx.insert(this.tables["t_persistence_state"]).values({
+				fSingleton: 1,
+				fStoreId: randomUUID()
+			}).onConflictDoNothing().execute();
+			const id = (await tx.select({ fStoreId: this.tables["t_persistence_state"].fStoreId }).from(this.tables["t_persistence_state"]).where(eq(this.tables["t_persistence_state"].fSingleton, 1)).execute())[0]?.fStoreId;
+			if (id === void 0 || id.length === 0) throw new Error("session database has no valid store identity");
+			return id;
+		});
+		this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
+	}
+	async baselineV2() {
+		const dir = (await readdir(postgresMigrationsDir)).find((name) => name.endsWith("_v2_initial"));
+		if (dir === void 0) throw new Error("missing v2 baseline migration in drizzle/postgres");
+		await this.db.execute(sql`
+      CREATE SCHEMA IF NOT EXISTS drizzle
+    `);
+		await this.db.execute(sql`
+      CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
+        id SERIAL PRIMARY KEY,
+        hash text NOT NULL,
+        created_at bigint,
+        name text,
+        applied_at timestamp with time zone DEFAULT now()
+      )
+    `);
+		await this.db.execute(sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at, name) VALUES ('baseline', 0, ${dir})`);
+	}
+	async close() {
+		await this.options.close();
+	}
+	async getSession(id) {
+		return (await this.db.select().from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
+	}
+	async getEventRows(id, fromSequence) {
+		return (fromSequence === void 0 ? this.eventRows(this.db).where(eq(this.tables["t_session_events"].fSessionId, id)) : this.eventRows(this.db).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence)))).orderBy(this.tables["t_session_events"].fSequence).execute();
+	}
+	async getEventTypeAt(id, sequence) {
+		const table = this.tables["t_session_events"];
+		return (await this.eventRows(this.db).where(and(eq(table.fSessionId, id), eq(table.fSequence, sequence))).limit(1).execute())[0]?.fType;
+	}
+	async getEventTypesBefore(id, beforeSequence, limit) {
+		const table = this.tables["t_session_events"];
+		return await this.eventRows(this.db).where(and(eq(table.fSessionId, id), lt(table.fSequence, beforeSequence))).orderBy(desc(table.fSequence)).limit(limit).execute();
+	}
+	async listSessions() {
+		return this.db.select().from(this.tables["t_sessions"]).execute();
+	}
+	async transaction(fn) {
+		return this.db.transaction(async (tx) => fn(this.txFor(tx)));
+	}
+	txFor(tx) {
+		return {
+			upsertSession: (storage, incarnation) => this.upsertSession(tx, storage, incarnation),
+			getHead: (id) => this.getHead(tx, id),
+			getSeedLength: (id) => this.getSeedLength(tx, id),
+			updateSeedLength: (id, seedLength) => this.updateSeedLength(tx, id, seedLength),
+			insertEvents: (events) => this.insertEvents(tx, events),
+			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),
+			deleteSession: (id) => this.deleteSession(tx, id),
+			deleteSessions: (ids) => this.deleteSessions(tx, ids)
+		};
+	}
+	async readMeta(exec, key) {
+		return (await exec.select({ fValue: this.tables["t_schema_meta"].fValue }).from(this.tables["t_schema_meta"]).where(eq(this.tables["t_schema_meta"].fKey, key)).execute())[0]?.fValue;
+	}
+	async upsertSession(exec, storage, incarnation) {
+		await exec.insert(this.tables["t_sessions"]).values(sessionInsertRow(storage, incarnation)).onConflictDoUpdate({
+			target: this.tables["t_sessions"].fSessionId,
+			set: sessionConflictRow(storage)
+		}).execute();
+	}
+	async getHead(exec, id) {
+		const head = (await exec.select({
+			fHeadEventId: this.tables["t_sessions"].fHeadEventId,
+			fHeadSequence: this.tables["t_sessions"].fHeadSequence
+		}).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
+		if (head === void 0) throw new Error(`session "${id}" has no materialized row`);
+		return head;
+	}
+	async getSeedLength(exec, id) {
+		const row = (await exec.select({ fSeedLength: this.tables["t_sessions"].fSeedLength }).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
+		if (row === void 0) throw new Error(`session "${id}" has no materialized row`);
+		return row.fSeedLength;
+	}
+	async updateSeedLength(exec, id, seedLength) {
+		await exec.update(this.tables["t_sessions"]).set({ fSeedLength: seedLength }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+	}
+	static INSERT_BATCH_ROWS = 1e3;
+	async insertEvents(exec, events) {
+		if (events.length === 0) return;
+		for (let i = 0; i < events.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_events"]).values(events.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).execute();
+		const usage = events.flatMap((event) => {
+			const row = usageRowOf(event);
+			return row === void 0 ? [] : [row];
+		});
+		if (usage.length > 0) await exec.insert(this.tables["t_event_usage"]).values(usage).onConflictDoNothing().execute();
+	}
+	async insertBridges(exec, rows) {
+		if (rows.length === 0) return;
+		for (let i = 0; i < rows.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_session_events"]).values(rows.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).execute();
+	}
+	async updateHead(exec, id, headEventId, headSequence) {
+		await exec.update(this.tables["t_sessions"]).set({
+			fHeadEventId: headEventId,
+			fHeadSequence: headSequence
+		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+	}
+	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();
+	}
+	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();
+	}
+	async deleteSession(exec, id) {
+		await exec.delete(this.tables["t_session_events"]).where(eq(this.tables["t_session_events"].fSessionId, id)).execute();
+		await exec.delete(this.tables["t_workspace_sessions"]).where(eq(this.tables["t_workspace_sessions"].fSessionId, id)).execute();
+		await exec.delete(this.tables["t_session_projcache_row"]).where(eq(this.tables["t_session_projcache_row"].fSessionId, id)).execute();
+		await exec.delete(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+	}
+	/** 事件行可能被多个会话共享（fork 派生），所以孤儿只能在全库范围内判定。 */
+	async collectOrphans() {
+		const tEvents = this.tables["t_events"];
+		const tEventUsage = this.tables["t_event_usage"];
+		const tSessionEvents = this.tables["t_session_events"];
+		const result = await this.db.delete(tEvents).where(notInArray(tEvents.fEventId, this.db.select({ fEventId: tSessionEvents.fEventId }).from(tSessionEvents))).execute();
+		await this.db.delete(tEventUsage).where(notInArray(tEventUsage.fEventId, this.db.select({ fEventId: tEvents.fEventId }).from(tEvents))).execute();
+		return result.rowCount ?? 0;
+	}
+	/** 父会话被删后留下的 subagent 会话：父已不在表里，或本来就没有父。 */
+	async listOrphanSubagentSessions() {
+		const tSessions = this.tables["t_sessions"];
+		return (await this.db.execute(sql`
+      SELECT s.f_session_id AS id FROM ${tSessions} AS s
+      WHERE s.f_origin = 'subagent'
+        AND (s.f_parent_session IS NULL
+             OR s.f_parent_session NOT IN (SELECT p.f_session_id FROM ${tSessions} AS p))
+    `)).rows.map((row) => row.id);
+	}
+	async deleteSessions(exec, ids) {
+		if (ids.length === 0) return 0;
+		await exec.delete(this.tables["t_session_events"]).where(inArray(this.tables["t_session_events"].fSessionId, ids)).execute();
+		await exec.delete(this.tables["t_workspace_sessions"]).where(inArray(this.tables["t_workspace_sessions"].fSessionId, ids)).execute();
+		await exec.delete(this.tables["t_session_projcache_row"]).where(inArray(this.tables["t_session_projcache_row"].fSessionId, ids)).execute();
+		return (await exec.delete(this.tables["t_sessions"]).where(inArray(this.tables["t_sessions"].fSessionId, ids)).execute()).rowCount ?? 0;
+	}
+	async vacuum() {
+		await this.db.execute(sql`VACUUM ANALYZE`);
+	}
+	/** 一次性回填：旧库没写过 `t_event_usage`，建表后按事件行补一次（表非空即跳过）。 */
+	async backfillEventUsage() {
+		const tEventUsage = this.tables["t_event_usage"];
+		const tEvents = this.tables["t_events"];
+		const existing = await this.db.execute(sql`SELECT count(*) AS n FROM ${tEventUsage}`);
+		if (Number(existing.rows[0]?.["n"] ?? 0) > 0) return;
+		await this.db.execute(sql`
+      INSERT INTO ${tEventUsage} (
+        f_event_id, f_created_at, f_provider, f_model,
+        f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
+      SELECT e.f_event_id, e.f_created_at,
+             coalesce(e.f_data::json #>> '{data,message,source,provider}',
+                      e.f_data::json #>> '{message,source,provider}'),
+             coalesce(e.f_data::json #>> '{data,message,source,model}',
+                      e.f_data::json #>> '{message,source,model}'),
+             coalesce((e.f_data::json #>> '{data,usage,inputTokens}')::integer,
+                      (e.f_data::json #>> '{usage,inputTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,outputTokens}')::integer,
+                      (e.f_data::json #>> '{usage,outputTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,cacheReadTokens}')::integer,
+                      (e.f_data::json #>> '{usage,cacheReadTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,reasoningTokens}')::integer,
+                      (e.f_data::json #>> '{usage,reasoningTokens}')::integer, 0),
+             coalesce((e.f_data::json #>> '{data,usage,totalTokens}')::integer,
+                      (e.f_data::json #>> '{usage,totalTokens}')::integer, 0)
+        FROM ${tEvents} e
+       WHERE e.f_type = 'assistant/message'
+         AND (e.f_data::json #> '{data,usage}' IS NOT NULL
+              OR e.f_data::json #> '{usage}' IS NOT NULL)
+      ON CONFLICT DO NOTHING
+    `);
+	}
+	/** 用量聚合：与 SQLite 侧同形，读 `t_event_usage`，数值列回来是字符串。 */
+	async usageReport(sinceMs) {
+		const sinceClause = sinceMs === void 0 ? sql`` : sql` AND u.f_created_at >= ${sinceMs}`;
+		const tEventUsage = this.tables["t_event_usage"];
+		const tSessionEvents = this.tables["t_session_events"];
+		const tSessions = this.tables["t_sessions"];
+		const buckets = await this.db.execute(sql`
+      SELECT to_char(to_timestamp(u.f_created_at / 1000.0), 'YYYY-MM-DD') AS day,
+             u.f_provider AS provider,
+             u.f_model AS model,
+             EXISTS (SELECT 1 FROM ${tSessionEvents} sb
+                       JOIN ${tSessions} ss ON ss.f_session_id = sb.f_session_id
+                      WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent') AS subagent,
+             count(*) AS events,
+             sum(u.f_input_tokens) AS input_tokens,
+             sum(u.f_output_tokens) AS output_tokens,
+             sum(u.f_cache_read_tokens) AS cache_read_tokens,
+             sum(u.f_reasoning_tokens) AS reasoning_tokens,
+             sum(u.f_total_tokens) AS total_tokens
+        FROM ${tEventUsage} u
+       WHERE EXISTS (SELECT 1 FROM ${tSessionEvents} rb WHERE rb.f_event_id = u.f_event_id)${sinceClause}
+       GROUP BY 1, 2, 3, 4
+    `);
+		const sessions = await this.db.execute(sql`
+      SELECT b.f_session_id AS session_id,
+             s.f_title AS title,
+             (s.f_origin = 'subagent') AS subagent,
+             (s.f_archived_at IS NOT NULL) AS archived,
+             count(*) AS events,
+             sum(u.f_input_tokens) AS input_tokens,
+             sum(u.f_output_tokens) AS output_tokens,
+             sum(u.f_cache_read_tokens) AS cache_read_tokens,
+             sum(u.f_reasoning_tokens) AS reasoning_tokens,
+             sum(u.f_total_tokens) AS total_tokens
+        FROM ${tSessionEvents} b
+        JOIN ${tEventUsage} u ON u.f_event_id = b.f_event_id
+        JOIN ${tSessions} s ON s.f_session_id = b.f_session_id
+       WHERE 1 = 1${sinceClause}
+       GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at
+    `);
+		return {
+			buckets: buckets.rows.map((row) => ({
+				day: String(row["day"]),
+				provider: text(row["provider"]),
+				model: text(row["model"]),
+				subagent: row["subagent"] === true,
+				...totalsOfRow(row)
+			})),
+			sessions: sessions.rows.map((row) => ({
+				sessionId: String(row["session_id"]),
+				title: text(row["title"]),
+				subagent: row["subagent"] === true,
+				archived: row["archived"] === true,
+				...totalsOfRow(row)
+			}))
+		};
+	}
+	async getPrevBridge(exec, id, sequence) {
+		return (await exec.select({
+			fEventId: this.tables["t_session_events"].fEventId,
+			fSequence: this.tables["t_session_events"].fSequence
+		}).from(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), eq(this.tables["t_session_events"].fSequence, sequence))).execute())[0];
+	}
+	eventRows(exec) {
+		return exec.select({
+			fEventId: this.tables["t_session_events"].fEventId,
+			fSequence: this.tables["t_session_events"].fSequence,
+			fType: this.tables["t_events"].fType,
+			fKind: this.tables["t_events"].fKind,
+			fRole: this.tables["t_events"].fRole,
+			fName: this.tables["t_events"].fName,
+			fActionId: this.tables["t_events"].fActionId,
+			fCreatedAt: this.tables["t_events"].fCreatedAt,
+			fData: this.tables["t_events"].fData,
+			fSurfaceOp: this.tables["t_session_events"].fSurfaceOp
+		}).from(this.tables["t_session_events"]).innerJoin(this.tables["t_events"], eq(this.tables["t_session_events"].fEventId, this.tables["t_events"].fEventId));
+	}
+};
+//#endregion
+//#region src/deletion.ts
+const SESSION_DELETE_PATH = "/api/session.delete";
+const STATUS_OF_DELETION_ERROR = {
+	SESSION_NOT_FOUND: 404,
+	SESSION_NOT_ARCHIVED: 409,
+	SESSION_LIVE: 409
+};
+function registerSessionDeletion(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_DELETE_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				let envelope;
+				try {
+					envelope = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				if (typeof envelope.sessionId !== "string" || envelope.sessionId === "") {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "missing sessionId field" }));
+					return;
+				}
+				try {
+					await persistence.deleteSession(envelope.sessionId);
+				} catch (error) {
+					if (error instanceof SessionDeletionError) {
+						res.writeHead(STATUS_OF_DELETION_ERROR[error.code], { "content-type": "application/json" });
+						res.end(JSON.stringify({
+							error: error.message,
+							code: error.code
+						}));
+						return;
+					}
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "session deletion failed" }));
+					return;
+				}
+				res.writeHead(200, { "content-type": "application/json" });
+				res.end(JSON.stringify({ deleted: envelope.sessionId }));
+			}
+		}));
+	});
+}
+//#endregion
+//#region src/export.ts
+const SESSION_EXPORT_PATH = "/api/session.export";
+/** 文件名只保留安全字符：会话 id 来自请求体，会写进 Content-Disposition。 */
+function safeFilename(sessionId) {
+	return sessionId.replace(/[^A-Za-z0-9._-]/gu, "_");
+}
+/** fflate 只给回调式异步 API（同步变体被 node/no-sync 禁止）。 */
+function zipBytes(files) {
+	return new Promise((resolve, reject) => {
+		zip(files, (error, data) => {
+			if (error === null) resolve(data);
+			else reject(error);
+		});
+	});
+}
+/** 导出通道：直接把会话日志打成 zip 响应体，与导入通道读同一份 artifact。 */
+function registerSessionExport(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_EXPORT_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				let envelope;
+				try {
+					envelope = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				if (typeof envelope.sessionId !== "string" || envelope.sessionId === "") {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "missing sessionId field" }));
+					return;
+				}
+				const sessionId = envelope.sessionId;
+				try {
+					const raw = await persistence.readRaw(sessionId);
+					if (raw === void 0) {
+						res.writeHead(404, { "content-type": "application/json" });
+						res.end(JSON.stringify({ error: `session "${sessionId}" not found` }));
+						return;
+					}
+					const zipFile = await zipBytes({ [raw.filename]: strToU8(raw.content) });
+					res.writeHead(200, {
+						"content-type": "application/zip",
+						"content-length": String(zipFile.byteLength),
+						"content-disposition": `attachment; filename="${safeFilename(sessionId)}.zip"`
+					});
+					res.end(Buffer.from(zipFile));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "session export failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_EXPORT_PATH} route`);
+	});
+}
+//#endregion
+//#region src/gc.ts
+const SESSION_GC_PATH = "/api/session.gc";
+/** 让所有运行中的 agent 先退场：GC 要重写事件表，运行中的写路径必须停下来。 */
+async function stopRunningAgents(ctx) {
+	const running = ctx.get("agents")?.list() ?? [];
+	for (const agent of running) agent.cancel?.({ kind: "user" }, { keepInbox: true });
+	await Promise.all(running.map((agent) => agent.whenIdle()));
+	return running.length;
+}
+/** GC 通道：停 agent → 回收孤儿事件行 → VACUUM，一次请求完成。 */
+function registerSessionGc(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_GC_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				try {
+					const stoppedAgents = await stopRunningAgents(webCtx);
+					const orphanSessions = await persistence.collectOrphanSessions();
+					const orphanEvents = await persistence.collectOrphans();
+					await persistence.vacuum();
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({
+						orphanSessions,
+						orphanEvents,
+						stoppedAgents,
+						vacuumed: true
+					}));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "gc failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_GC_PATH} route`);
+	});
+}
+//#endregion
+//#region src/usage.ts
+const SESSION_USAGE_PATH = "/api/session.usage";
+const DAY_MS = 864e5;
+const ROLLING_DAYS = {
+	"7d": 7,
+	"30d": 30,
+	"90d": 90
+};
+function localDayStart(now) {
+	const start = new Date(now);
+	start.setHours(0, 0, 0, 0);
+	return start;
+}
+/**
+* 范围起点（含），不限时为 undefined。自然日 / 自然周按 host 的本地时区算，周边界是周一 00:00。
+* @param range - 语义键。
+* @param now - 当前时刻。
+* @returns 起点毫秒时间戳，或 undefined。
+*/
+function resolveUsageSince(range, now) {
+	switch (range) {
+		case "all": return;
+		case "day": return localDayStart(now).getTime();
+		case "week": {
+			const start = localDayStart(now);
+			start.setDate(start.getDate() - (start.getDay() + 6) % 7);
+			return start.getTime();
+		}
+		default: return now - ROLLING_DAYS[range] * DAY_MS;
+	}
+}
+function parseUsageRange(value) {
+	return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d" ? value : "all";
+}
+function emptyTotals() {
+	return {
+		events: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		reasoningTokens: 0,
+		totalTokens: 0
+	};
+}
+/** 折叠一组行（桶或会话行）的用量。 */
+function sumUsage(rows) {
+	const totals = emptyTotals();
+	for (const row of rows) {
+		totals.events += row.events;
+		totals.inputTokens += row.inputTokens;
+		totals.outputTokens += row.outputTokens;
+		totals.cacheReadTokens += row.cacheReadTokens;
+		totals.reasoningTokens += row.reasoningTokens;
+		totals.totalTokens += row.totalTokens;
+	}
+	return totals;
+}
+/**
+* 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
+* 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
+*/
+function registerSessionUsage(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_USAGE_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const raw = Buffer.concat(chunks).toString("utf8");
+				let envelope = {};
+				if (raw !== "") try {
+					envelope = JSON.parse(raw);
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				try {
+					const aggregate = await persistence.usageReport(resolveUsageSince(parseUsageRange(envelope.range), Date.now()));
+					const totals = sumUsage(aggregate.buckets);
+					const subagent = sumUsage(aggregate.buckets.filter((bucket) => bucket.subagent));
+					const human = sumUsage(aggregate.buckets.filter((bucket) => !bucket.subagent));
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({
+						totals,
+						subagent,
+						human,
+						...aggregate
+					}));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "usage report failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_USAGE_PATH} route`);
+	});
+}
+//#endregion
+//#region src/session-query.ts
+var SessionQueryRdb = class extends SessionQueryEngine {
+	constructor(ctx, config = {}) {
+		super(ctx, config);
+	}
+	async searchSessions() {
+		throw searchDisabled();
+	}
+	async searchEvents() {
+		throw searchDisabled();
+	}
+};
+function searchDisabled() {
+	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");
+}
+//#endregion
+//#region src/storage-takeover/projection-cache.ts
+const SESSION_PROJECTION_CACHE_SERVICE = "sessionProjectionCache";
+const PREDECESSOR_TITLE_KEY = "title";
+var SessionProjectionCacheRdb = class extends Service {
+	static inject = ["sessionProjections", "sessions"];
+	records = /* @__PURE__ */ new Map();
+	dirty = /* @__PURE__ */ new Map();
+	directReads;
+	config;
+	repository;
+	ready;
+	constructor(ctx, options) {
+		super(ctx, SESSION_PROJECTION_CACHE_SERVICE);
+		this.config = options;
+		this.repository = options.repository;
+		this.ready = options.ready;
+		this.directReads = options.repository.readProjcacheDirect !== void 0;
+	}
+	async [Service.init]() {
+		this.installWritePath();
+		await this.ready;
+		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, entry);
+	}
+	lookup(id) {
+		if (this.directReads) return this.repository.readProjcacheDirect?.(id);
+		return this.records.get(id);
+	}
+	recordFor(id, expected) {
+		const record = this.lookup(id);
+		if (record === void 0) return void 0;
+		return identityMatches(record.identity, expected) ? record : void 0;
+	}
+	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);
+	}
+	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.readSessionTitleDirect?.(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
+		};
+	}
+	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
+		};
+	}
+	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
+		};
+	}
+	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));
+		}
+	}
+	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);
+	}
+	async truncateTo(meta, inheritedEventCount, headSeq) {
+		const identity = identityOf(meta, inheritedEventCount);
+		const record = this.recordFor(meta.id, identity);
+		if (record === void 0) return;
+		const rows = Object.fromEntries(Object.entries(record.rows).filter(([, row]) => row.seq <= headSeq));
+		await this.put(meta.id, identity, rows);
+	}
+	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");
+	}
+	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)}`);
+		}
+	}
+	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;
+		}
+	}
+	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
+		});
+	}
+};
+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);
+}
+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
+	};
+}
+function identityMatches(stored, expected) {
+	return stored.formatVersion === expected.formatVersion && lifecycleIdentityMatches(stored, expected);
+}
+function predecessorIdentityMatches(stored, expected) {
+	return (stored.formatVersion === void 0 || stored.formatVersion < expected.formatVersion) && lifecycleIdentityMatches(stored, expected);
+}
+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
+const WORKSPACE_UNIT = "workspace";
+const WORKSPACE_TABLE = "workspaces";
+var RdbStorageBackend = class {
+	repository;
+	kv = { open: (descriptor) => this.openUnit(descriptor) };
+	open = /* @__PURE__ */ new Map();
+	closed = false;
+	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 (descriptor.layout !== void 0 && descriptor.layout !== "single") throw new Error(`rdb storage backend serves only the 'single' layout (domain '${descriptor.name}' declares '${descriptor.layout}')`);
+		if (this.open.has(descriptor.name)) throw new Error(`kv unit '${descriptor.name}' is already open (double-open is a caller bug)`);
+		const unit = new WorkspaceKvUnit(this.repository, descriptor);
+		this.open.set(descriptor.name, unit);
+		try {
+			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}`);
+		} catch (error) {
+			this.open.delete(descriptor.name);
+			throw error;
+		}
+		unit.onClose(() => {
+			this.open.delete(descriptor.name);
+		});
+		return unit;
+	}
+	async close() {
+		this.closed = true;
+		const units = [...this.open.values()];
+		this.open.clear();
+		await Promise.all(units.map((unit) => unit.close()));
+	}
+};
+var WorkspaceKvUnit = class {
+	repository;
+	descriptor;
+	closed = false;
+	inflight = /* @__PURE__ */ new Set();
+	onClosed;
+	constructor(repository, descriptor) {
+		this.repository = repository;
+		this.descriptor = descriptor;
+	}
+	onClose(release) {
+		this.onClosed = release;
+	}
+	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.track(this.repository.putWorkspace(key, workspaceRecordOf(value)));
+	}
+	async deleteRecord(table, key) {
+		this.assertOpen();
+		this.assertTable(table);
+		await this.track(this.repository.deleteWorkspace(key));
+	}
+	async setGlobal(value) {
+		this.assertOpen();
+		await this.track(this.repository.writeWorkspaceState(workspaceStateOf(value)));
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		while (this.inflight.size > 0) await Promise.allSettled(this.inflight);
+		this.onClosed?.();
+	}
+	async track(operation) {
+		const settled = operation.then(() => void 0, () => void 0);
+		this.inflight.add(settled);
+		try {
+			await operation;
+		} finally {
+			this.inflight.delete(settled);
+		}
+	}
+	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}'`);
+	}
+};
+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
+	};
+}
+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
+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.plugin(SessionProjectionCacheRdb, {
+		...options.projectionCache,
+		repository: options.repository,
+		ready: options.ready
+	});
+}
+//#endregion
+//#region src/index.ts
+const DEFAULT_PROJECTION_WRITE_EVERY_EVENTS = 200;
+const DEFAULT_PROJECTION_WRITE_INTERVAL_MS = 5e3;
+var SessionDeletionError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "SessionDeletionError";
+	}
+};
+var RdbBackendTracker = class {
+	name;
+	writers = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	openHandles = /* @__PURE__ */ new Set();
+	counter = 0;
+	constructor(name) {
+		this.name = name;
+	}
+	registerCreated(header, inheritedEventCount) {
+		if (this.writers.has(header.id)) throw new SessionAlreadyExistsError(header.id);
+		this.writers.set(header.id, null);
+		this.pending.set(header.id, {
+			header,
+			revision: SessionPersistenceRevision(`memory:${this.name}:${++this.counter}`),
+			inheritedEventCount,
+			cursor: 0,
+			everAppended: false
+		});
+	}
+	updatePending(id, cursor, everAppended) {
+		const entry = this.pending.get(id);
+		if (entry === void 0) return;
+		this.pending.set(id, {
+			...entry,
+			cursor,
+			everAppended
+		});
+	}
+	claimWrite(id) {
+		if (this.writers.has(id)) throw new SessionAlreadyOwnedError(id);
+		this.writers.set(id, null);
+	}
+	releaseClaim(id) {
+		this.writers.delete(id);
+	}
+	pendingOf(id) {
+		return this.pending.get(id);
+	}
+	hasPending(id) {
+		return this.pending.has(id);
+	}
+	pendingEntries() {
+		return this.pending.entries();
+	}
+	materialized(id) {
+		this.pending.delete(id);
+	}
+	adopt(handle) {
+		this.openHandles.add(handle);
+		if (handle.access === "write") this.writers.set(handle.id, handle);
+		return handle;
+	}
+	release(handle, materialized) {
+		this.openHandles.delete(handle);
+		if (handle.access !== "write") return;
+		this.writers.delete(handle.id);
+		if (!materialized) this.pending.delete(handle.id);
+	}
+	writerOf(id) {
+		const writer = this.writers.get(id);
+		return writer === null ? void 0 : writer;
+	}
+	hasOpenHandle(id) {
+		for (const handle of this.openHandles) if (handle.id === id) return true;
+		return false;
+	}
+	async flushAll() {
+		const errors = [];
+		for (const writer of this.writers.values()) {
+			if (writer === null) continue;
+			try {
+				await writer.drainLive();
+				await writer.flush();
+			} catch (error) {
+				if (error instanceof SessionHandleClosedError) continue;
+				errors.push(error);
+			}
+		}
+		if (errors.length > 0) throw new AggregateError(errors, `${this.name} flush failed`);
+	}
+	async closeAll() {
+		const errors = [];
+		for (const handle of this.openHandles) try {
+			await handle.close();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new AggregateError(errors, `${this.name} dispose failed`);
+	}
+};
+var RdbSessionHandle = class RdbSessionHandle {
+	persistence;
+	id;
+	header;
+	access;
+	state;
+	chain = Promise.resolve();
+	closing;
+	cursor;
+	materialized;
+	buffered = [];
+	batchTimer;
+	drainPaused = false;
+	draining;
+	tornTruncateTo;
+	everAppended = false;
+	constructor(persistence, id, header, access, state) {
+		this.persistence = persistence;
+		this.id = id;
+		this.header = header;
+		this.access = access;
+		this.state = state;
+		this.cursor = state.cursor;
+		this.materialized = state.materialized;
+		this.tornTruncateTo = state.tornTruncateTo;
+	}
+	get inheritedEventCount() {
+		return this.state.inheritedEventCount;
+	}
+	get cursorValue() {
+		return this.cursor;
+	}
+	async read(offset = 0, length = Number.MAX_SAFE_INTEGER, options) {
+		this.assertOpen("read");
+		if (!Number.isSafeInteger(offset) || offset < 0) throw new TypeError(`read offset must be a non-negative safe integer, got ${String(offset)}`);
+		if (!Number.isSafeInteger(length) || length < 0) throw new TypeError(`read length must be a non-negative safe integer, got ${String(length)}`);
+		options?.signal?.throwIfAborted();
+		const log = await this.persistence.readLog(this.id, {}, options?.signal);
+		if (log === void 0) {
+			if (this.persistence.tracker.hasPending(this.id)) return {
+				eventState: "detached",
+				events: []
+			};
+			throw new SessionPersistenceNotFoundError(this.id);
+		}
+		repairReadView(log.events);
+		return {
+			eventState: "detached",
+			events: log.events.slice(offset, offset + length)
+		};
+	}
+	async append(events, options) {
+		this.assertOpen("append");
+		const batch = materializeAppendBatch(events);
+		return this.run("append", async () => {
+			options?.signal?.throwIfAborted();
+			if (this.access !== "write") throw new SessionReadOnlyError(this.id, "append");
+			if (batch.length === 0) return;
+			this.everAppended = true;
+			assertContiguous(this.id, batch, this.cursor);
+			await this.persistence.appendBatch(this.header, this.state.inheritedEventCount, batch, this.tornTruncateTo);
+			this.tornTruncateTo = void 0;
+			this.cursor += batch.length;
+			this.materialized = true;
+			this.persistence.tracker.updatePending(this.id, this.cursor, true);
+		});
+	}
+	async flush(options) {
+		return this.run("flush", async () => {
+			options?.signal?.throwIfAborted();
+			if (this.access !== "write") throw new SessionReadOnlyError(this.id, "flush");
+			if (this.materialized) return;
+			await this.persistence.materializeEmpty(this.header, this.state.inheritedEventCount);
+			this.materialized = true;
+		});
+	}
+	close() {
+		return this.closing ??= (async () => {
+			let drainFailure;
+			for (;;) {
+				try {
+					await this.drainLive();
+				} catch (error) {
+					drainFailure = error;
+					break;
+				}
+				await this.chain;
+				if (this.buffered.length === 0) break;
+			}
+			await this.chain;
+			const failures = [];
+			if (drainFailure !== void 0) failures.push(drainFailure instanceof Error ? drainFailure : new Error(JSON.stringify(drainFailure)));
+			this.persistence.tracker.release(this, this.materialized || this.everAppended);
+			if (failures.length > 1) throw new AggregateError(failures, `session "${this.id}": close failed to drain`);
+			if (failures[0] !== void 0) throw failures[0];
+		})();
+	}
+	[Symbol.asyncDispose]() {
+		return this.close();
+	}
+	enqueueLive(event, reportBackgroundFailure) {
+		this.buffered.push(structuredClone(event));
+		if (this.batchTimer !== void 0 || this.drainPaused) return;
+		this.batchTimer = setTimeout(() => {
+			this.batchTimer = void 0;
+			this.drainLive().catch(reportBackgroundFailure);
+		}, RdbSessionHandle.LIVE_WRITE_BATCH_MAX_DELAY_MS);
+	}
+	resetAfterRewind(cursor, inheritedEventCount) {
+		this.cursor = cursor;
+		if (inheritedEventCount !== void 0) this.state.inheritedEventCount = SessionLogOffset(inheritedEventCount);
+	}
+	drainLive() {
+		return this.draining ??= this.drainBuffered().finally(() => {
+			this.draining = void 0;
+		});
+	}
+	async drainBuffered() {
+		if (this.batchTimer !== void 0) {
+			clearTimeout(this.batchTimer);
+			this.batchTimer = void 0;
+		}
+		this.drainPaused = false;
+		while (this.buffered.length > 0) await this.enqueueChain(async () => {
+			const batch = this.buffered.splice(0);
+			try {
+				const fresh = batch.filter((event) => event.seq >= this.cursor);
+				if (fresh.length === 0) return;
+				for (const [index, event] of fresh.entries()) if (event.seq !== this.cursor + index) throw new Error(`append seq mismatch for "${this.id}": expected ${this.cursor + index} at index ${index}, got ${event.seq}`);
+				await this.persistence.appendBatch(this.header, this.state.inheritedEventCount, fresh, this.tornTruncateTo);
+				this.tornTruncateTo = void 0;
+				this.cursor += fresh.length;
+				this.materialized = true;
+			} catch (error) {
+				this.buffered = batch.concat(this.buffered);
+				this.drainPaused = true;
+				throw error;
+			}
+		});
+	}
+	enqueueChain(op) {
+		const next = this.chain.then(op);
+		this.chain = next.catch(() => {});
+		return next;
+	}
+	async run(operation, op) {
+		this.assertOpen(operation);
+		return this.enqueueChain(async () => {
+			this.assertOpen(operation);
+			return op();
+		});
+	}
+	assertOpen(operation) {
+		if (this.closing !== void 0) throw new SessionHandleClosedError(this.id, operation);
+	}
+	static LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
+};
+var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersistence {
+	config;
+	static inject = ["sessions", "settings"];
+	static Config = z.union([z.object({
+		type: z.const("sqlite"),
+		path: z.string().required(),
+		journalMode: z.union([
+			"wal",
+			"delete",
+			"truncate",
+			"persist"
+		]).default("wal"),
+		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"),
+		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";
+	tracker = new RdbBackendTracker(this.name);
+	backend;
+	storeIdentity;
+	ready;
+	writeGuard = new WriteGuard();
+	reuseEventIds = /* @__PURE__ */ new Map();
+	liveBuffers = /* @__PURE__ */ new Map();
+	liveReady = /* @__PURE__ */ new Map();
+	constructor(ctx, config, injectedBackend) {
+		let resolved = config;
+		const settings = ctx.reflect.get("settings");
+		if (settings !== void 0) {
+			const scope = settings.register(SessionPersistenceRdb.settingsNs, SessionPersistenceRdb.Config, { base: config });
+			resolved = scope.get();
+			scope.watch(() => {
+				ctx.logger.warn("session-rdb: settings changed; restart to apply the new configuration");
+			});
+		}
+		super(ctx);
+		this.config = config;
+		this.config = resolved;
+		this.backend = injectedBackend ?? createBackend(resolved);
+		this.ready = this.init();
+		this.installLiveRouting(ctx);
+		new SessionBranchRdb(this.ctx);
+		this.ctx.plugin(SessionQueryRdb, {});
+		registerSessionImport(this.ctx, this);
+		registerSessionDeletion(this.ctx, this);
+		registerSessionExport(this.ctx, this);
+		registerSessionGc(this.ctx, this);
+		registerSessionUsage(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();
+		this.storeIdentity = this.backend.storeIdentity;
+	}
+	async create(header, options) {
+		options?.signal?.throwIfAborted();
+		const snapshot = materializeCreateHeader(header);
+		if (snapshot.isSeeded && options?.inheritedEventCount === void 0) throw new TypeError("seeded session metadata requires an inherited event count");
+		const inheritedEventCount = SessionLogOffset(options?.inheritedEventCount ?? 0);
+		if (!snapshot.isSeeded && inheritedEventCount !== 0) throw new TypeError("unseeded session metadata inherited event count must be 0");
+		await this.ready;
+		options?.signal?.throwIfAborted();
+		if (this.tracker.hasPending(snapshot.id) || await this.backend.getSession(snapshot.id) !== void 0) throw new SessionAlreadyExistsError(snapshot.id);
+		this.tracker.registerCreated(snapshot, inheritedEventCount);
+		return this.tracker.adopt(new RdbSessionHandle(this, snapshot.id, snapshot, "write", {
+			cursor: 0,
+			materialized: false,
+			inheritedEventCount
+		}));
+	}
+	async open(id, access, options) {
+		options?.signal?.throwIfAborted();
+		await this.ready;
+		options?.signal?.throwIfAborted();
+		const pending = this.tracker.pendingOf(id);
+		if (access === "read") {
+			if (pending !== void 0) return this.tracker.adopt(new RdbSessionHandle(this, id, pending.header, "read", {
+				cursor: 0,
+				materialized: false,
+				inheritedEventCount: pending.inheritedEventCount
+			}));
+			const log = await this.readLog(id, {}, options?.signal);
+			if (log === void 0) throw new SessionPersistenceNotFoundError(id);
+			repairReadView(log.events);
+			validateStoredEvents(log.meta, log.events);
+			return this.tracker.adopt(new RdbSessionHandle(this, id, log.meta, "read", {
+				cursor: log.events.length,
+				materialized: true,
+				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
+			}));
+		}
+		this.tracker.claimWrite(id);
+		try {
+			if (pending !== void 0) return this.tracker.adopt(new RdbSessionHandle(this, id, pending.header, "write", {
+				cursor: pending.cursor,
+				materialized: false,
+				inheritedEventCount: pending.inheritedEventCount
+			}));
+			const log = await this.readLog(id, {}, options?.signal);
+			if (log === void 0) throw new SessionPersistenceNotFoundError(id);
+			repairReadView(log.events);
+			validateStoredEvents(log.meta, log.events);
+			if (log.migrated && log.events.length !== log.storedCount) await this.rewriteMigratedLog(id, log);
+			this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
+			return this.tracker.adopt(new RdbSessionHandle(this, id, log.meta, "write", {
+				cursor: log.events.length,
+				materialized: true,
+				inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
+				...log.tornFrom !== void 0 ? { tornTruncateTo: log.tornFrom } : {}
+			}));
+		} catch (error) {
+			this.tracker.releaseClaim(id);
+			throw error;
+		}
+	}
+	flush() {
+		return this.tracker.flushAll();
+	}
+	async stat(id, options) {
+		options?.signal?.throwIfAborted();
+		await this.ready;
+		options?.signal?.throwIfAborted();
+		const pending = this.tracker.pendingOf(id);
+		if (pending !== void 0) return {
+			header: pending.header,
+			revision: pending.revision
+		};
+		const row = await this.backend.getSession(id);
+		if (row === void 0) return void 0;
+		return {
+			header: rowToMeta(row),
+			revision: this.rowRevision(row)
+		};
+	}
+	async list(options) {
+		const signal = options?.signal;
+		const snapshots = [];
+		const listed = /* @__PURE__ */ new Set();
+		for (const [id, pending] of this.tracker.pendingEntries()) {
+			snapshots.push({
+				header: pending.header,
+				revision: pending.revision
+			});
+			listed.add(id);
+		}
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const rows = await this.backend.listSessions();
+		signal?.throwIfAborted();
+		for (const row of rows) {
+			if (listed.has(row.fSessionId)) continue;
+			snapshots.push({
+				header: rowToMeta(row),
+				revision: this.rowRevision(row)
+			});
+		}
+		return snapshots;
+	}
+	async deleteSession(id, signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const row = await this.backend.getSession(id);
+		if (row === void 0) throw new SessionDeletionError(`session "${id}" not found`, "SESSION_NOT_FOUND");
+		if (row.fArchivedAt === null) throw new SessionDeletionError(`session "${id}" is not archived; only archived sessions can be deleted`, "SESSION_NOT_ARCHIVED");
+		if (this.tracker.hasPending(id) || this.tracker.hasOpenHandle(id)) throw new SessionDeletionError(`session "${id}" is live; stop it before deleting`, "SESSION_LIVE");
+		await this.unarchiveBeforeDeletion(id);
+		await this.backend.transaction(async (tx) => {
+			await tx.deleteSession(id);
+		});
+		this.liveBuffers.delete(id);
+		this.liveReady.delete(id);
+		this.reuseEventIds.delete(id);
+	}
+	/** GC 通道：回收已无桥接行引用的事件行（孤儿），返回删除行数。 */
+	async collectOrphans() {
+		await this.ready;
+		return this.backend.collectOrphans();
+	}
+	/** GC 通道：回收父已不存在的 subagent 会话（live 的跳过），返回删除的会话数。 */
+	async collectOrphanSessions() {
+		await this.ready;
+		const deletable = (await this.backend.listOrphanSubagentSessions()).filter((id) => !this.tracker.hasPending(id) && !this.tracker.hasOpenHandle(id));
+		if (deletable.length === 0) return 0;
+		const deleted = await this.backend.transaction((tx) => tx.deleteSessions(deletable));
+		for (const id of deletable) {
+			this.liveBuffers.delete(id);
+			this.liveReady.delete(id);
+			this.reuseEventIds.delete(id);
+		}
+		return deleted;
+	}
+	/** 用量统计：SQL 聚合的按天 × 模型桶与按会话行（事件行去重、排除孤儿行）。 */
+	async usageReport(sinceMs) {
+		await this.ready;
+		return this.backend.usageReport(sinceMs);
+	}
+	/** GC 通道：VACUUM；调用方需先停止运行中的写路径（见 `registerSessionGc`）。 */
+	async vacuum() {
+		await this.ready;
+		await this.backend.vacuum();
+	}
+	async unarchiveBeforeDeletion(id) {
+		const registry = this.ctx.get("workspaceRegistry");
+		if (registry === void 0) return;
+		if (!registry.archivedSessionIds.includes(id)) return;
+		await registry.unarchiveSession(id);
+	}
+	async readRaw(id, signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const log = await this.readLog(id, {}, signal);
+		if (log === void 0) return void 0;
+		repairReadView(log.events);
+		const events = balanceRewindPrefix(log.events, { keepOpenTail: true });
+		const inheritedEventCount = Math.min(log.inheritedEventCount, events.length);
+		return {
+			meta: log.meta,
+			inheritedEventCount,
+			filename: sessionFormatLogFilename(SESSION_FORMAT_VERSION),
+			content: toJsonlArtifact(log.meta, inheritedEventCount, events)
+		};
+	}
+	async materializeEmpty(meta, inheritedEventCount) {
+		await this.ready;
+		await this.backend.transaction(async (tx) => {
+			await tx.upsertSession({
+				meta,
+				inheritedEventCount
+			}, randomUUID());
+			await tx.bumpRevision(meta.id);
+		});
+		this.tracker.materialized(meta.id);
+		this.writeGuard.confirmHead(meta.id, -1);
+	}
+	async appendBatch(meta, inheritedEventCount, events, tornTruncateTo) {
+		await this.ready;
+		if (events.length === 0) return false;
+		validateStoredEvents(meta, [...events]);
+		const reuse = this.reuseEventIds.get(meta.id);
+		if (reuse !== void 0) this.reuseEventIds.delete(meta.id);
+		let confirmedHead = -1;
+		await this.backend.transaction(async (tx) => {
+			if (tornTruncateTo !== void 0) {
+				await tx.deleteBridgeTail(meta.id, tornTruncateTo);
+				const prev = await tx.getPrevBridge(meta.id, tornTruncateTo - 1);
+				if (prev === void 0) await tx.updateHead(meta.id, "", -1);
+				else await tx.updateHead(meta.id, prev.fEventId, prev.fSequence);
+			}
+			await tx.upsertSession({
+				meta,
+				inheritedEventCount
+			}, randomUUID());
+			const head = await tx.getHead(meta.id);
+			this.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
+			const { headEventId, headSequence } = await appendEventTail(tx, meta, events, {
+				parentId: head.fHeadEventId,
+				nextSeq: head.fHeadSequence + 1
+			}, reuse);
+			await tx.updateHead(meta.id, headEventId, headSequence);
+			await tx.bumpRevision(meta.id);
+			confirmedHead = headSequence;
+		});
+		this.writeGuard.confirmHead(meta.id, confirmedHead);
+		this.tracker.materialized(meta.id);
+		return true;
+	}
+	async readLog(id, options = {}, signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const row = await this.backend.getSession(id);
+		if (row === void 0) return void 0;
+		const meta = rowToMeta(row);
+		const eventRows = options.fromSeq === void 0 ? await this.backend.getEventRows(id) : await this.backend.getEventRows(id, options.fromSeq);
+		signal?.throwIfAborted();
+		if (isLegacyVersion(row.fVersion)) try {
+			const converted = convertLegacyRows(row, eventRows);
+			return {
+				meta: converted.meta,
+				inheritedEventCount: converted.inheritedEventCount,
+				events: converted.events,
+				incarnation: row.fIncarnation,
+				revision: row.fRevision,
+				storedCount: eventRows.length,
+				migrated: true
+			};
+		} catch (error) {
+			this.ctx.logger.warn(`session-rdb: session "${id}" is not a single released format; adopting its stored rows as current-format data (${error instanceof Error ? error.message : String(error)})`);
+			const adopted = adoptLegacyRows(row, eventRows);
+			return {
+				meta: adopted.meta,
+				inheritedEventCount: adopted.inheritedEventCount,
+				events: adopted.events,
+				incarnation: row.fIncarnation,
+				revision: row.fRevision,
+				storedCount: eventRows.length,
+				migrated: false,
+				...adopted.tornFrom !== void 0 ? { tornFrom: adopted.tornFrom } : {}
+			};
+		}
+		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0);
+		return {
+			meta,
+			inheritedEventCount: row.fSeedLength ?? 0,
+			events: preserved,
+			incarnation: row.fIncarnation,
+			revision: row.fRevision,
+			storedCount: eventRows.length,
+			migrated: false,
+			...tornFrom !== void 0 ? { tornFrom } : {}
+		};
+	}
+	async rewriteMigratedLog(id, log) {
+		await this.backend.transaction(async (tx) => {
+			await tx.deleteBridgeTail(id, 0);
+			await tx.upsertSession({
+				meta: log.meta,
+				inheritedEventCount: SessionLogOffset(log.inheritedEventCount)
+			}, randomUUID());
+			const { headEventId, headSequence } = await appendEventTail(tx, log.meta, log.events, {
+				parentId: "",
+				nextSeq: 0
+			});
+			await tx.updateHead(id, headEventId, headSequence);
+			await tx.bumpRevision(id);
+		});
+	}
+	async listSnapshots(signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const snapshots = [];
+		const listed = /* @__PURE__ */ new Set();
+		for (const [id, pending] of this.tracker.pendingEntries()) {
+			snapshots.push({
+				header: pending.header,
+				revision: pending.revision,
+				inheritedEventCount: pending.inheritedEventCount
+			});
+			listed.add(id);
+		}
+		const rows = await this.backend.listSessions();
+		signal?.throwIfAborted();
+		for (const row of rows) {
+			if (listed.has(row.fSessionId)) continue;
+			snapshots.push({
+				header: rowToMeta(row),
+				revision: this.rowRevision(row),
+				inheritedEventCount: row.fSeedLength ?? 0
+			});
+		}
+		return snapshots;
+	}
+	async readStoredRevision(id, signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const row = await this.backend.getSession(id);
+		if (row === void 0) return void 0;
+		return this.rowRevision(row);
+	}
+	async createAndAppend(header, events, inheritedEventCount) {
+		const handle = await this.create(header, inheritedEventCount === void 0 ? void 0 : { inheritedEventCount: SessionLogOffset(inheritedEventCount) });
+		try {
+			if (events.length > 0) await handle.append(events);
+		} finally {
+			await handle.close();
+		}
+	}
+	async load(id, signal) {
+		const handle = await this.open(id, "read", signal === void 0 ? void 0 : { signal });
+		try {
+			const { events } = await handle.read(0, void 0, signal === void 0 ? void 0 : { signal });
+			const row = await this.backend.getSession(id);
+			if (row === void 0) throw new SessionPersistenceNotFoundError(id);
+			if (isLegacyVersion(row.fVersion)) return {
+				meta: handle.header,
+				inheritedEventCount: handle.inheritedEventCount,
+				events
+			};
+			return {
+				meta: rowToMeta(row),
+				inheritedEventCount: SessionLogOffset(row.fSeedLength ?? 0),
+				events
+			};
+		} finally {
+			await handle.close();
+		}
+	}
+	async append(id, events) {
+		const handle = await this.open(id, "write");
+		try {
+			await handle.append(events);
+		} finally {
+			await handle.close();
+		}
+	}
+	async readFrom(id, fromSeq, signal) {
+		const log = await this.readLog(id, { fromSeq }, signal);
+		if (log === void 0) throw new SessionPersistenceNotFoundError(id);
+		return {
+			meta: log.meta,
+			inheritedEventCount: log.inheritedEventCount,
+			events: log.events
+		};
+	}
+	async close() {
+		await this.ready;
+		await this.backend.close();
+	}
+	registerReuseEventIds(childId, map) {
+		this.reuseEventIds.set(childId, new Map(map));
+	}
+	internals() {
+		return {
+			backend: this.backend,
+			writeGuard: this.writeGuard,
+			create: (meta, inheritedEventCount) => this.create(meta, inheritedEventCount === void 0 ? void 0 : { inheritedEventCount: SessionLogOffset(inheritedEventCount) }),
+			append: (id, events) => this.append(id, events),
+			load: (id) => this.load(id),
+			inspect: (id, signal) => this.load(id, signal),
+			readFrom: (id, fromSeq, signal) => this.readFrom(id, fromSeq, signal),
+			listSnapshots: (signal) => this.listSnapshots(signal),
+			readStoredRevision: (id, signal) => this.readStoredRevision(id, signal),
+			registerReuseEventIds: (childId, map) => this.registerReuseEventIds(childId, map)
+		};
+	}
+	rowRevision(row) {
+		return SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`);
+	}
+	installLiveRouting(ctx) {
+		ctx.on("session/created", (session) => {
+			this.liveBuffers.set(session.id, []);
+			const ready = this.ensureLiveHandle(session);
+			this.liveReady.set(session.id, ready);
+			ready.catch((error) => {
+				ctx.logger.warn(`session-rdb: live session "${session.id}" persistence init failed: ${String(error)}`);
+			});
+		});
+		for (const session of ctx.sessions.list()) {
+			this.liveBuffers.set(session.id, []);
+			const ready = this.ensureLiveHandle(session);
+			this.liveReady.set(session.id, ready);
+			ready.catch((error) => {
+				ctx.logger.warn(`session-rdb: live session "${session.id}" persistence init failed: ${String(error)}`);
+			});
+		}
+		ctx.on("session/event", (session, event) => {
+			const handle = this.tracker.writerOf(session.id);
+			if (handle !== void 0) {
+				handle.enqueueLive(event, (error) => {
+					ctx.logger.warn(`session-rdb: background write for session "${session.id}" failed (buffered events retained): ${String(error)}`);
+				});
+				return;
+			}
+			this.liveBuffers.get(session.id)?.push(structuredClone(event));
+		});
+		ctx.on("session/flush", (session) => {
+			const handle = this.tracker.writerOf(session.id);
+			if (handle === void 0) {
+				const ready = this.liveReady.get(session.id);
+				if (ready === void 0) return void 0;
+				return ready.then(() => {
+					const settled = this.tracker.writerOf(session.id);
+					if (settled === void 0) return void 0;
+					return settled.drainLive().then(() => settled.flush());
+				});
+			}
+			return handle.drainLive().then(() => handle.flush());
+		});
+		ctx.on("session/disposed", (session) => {
+			const ready = this.liveReady.get(session.id);
+			this.liveBuffers.delete(session.id);
+			this.liveReady.delete(session.id);
+			const closeHandle = () => {
+				const handle = this.tracker.writerOf(session.id);
+				if (handle === void 0) return;
+				handle.close().catch((error) => {
+					ctx.logger.warn(`session-rdb: final drain for session "${session.id}" failed: ${String(error)}`);
+				});
+			};
+			if (ready === void 0) {
+				closeHandle();
+				return;
+			}
+			ready.then(closeHandle, closeHandle);
+		});
+		ctx.effect(() => async () => {
+			await Promise.allSettled(this.liveReady.values());
+			await this.tracker.closeAll();
+			await this.close();
+		}, `${this.name} open handles`);
+	}
+	async ensureLiveHandle(session) {
+		const id = session.header.id;
+		if (this.tracker.writerOf(id) !== void 0) return;
+		await this.ready;
+		const stored = await this.readLog(id, {});
+		let handle;
+		if (stored === void 0) {
+			handle = await this.create(session.header, { inheritedEventCount: session.inheritedEventCount });
+			const seed = session.snapshotEvents();
+			if (seed.length > 0) await handle.append(seed);
+		} else {
+			if (stored.meta.cwd !== session.header.cwd) throw new Error(`session "${id}" is already persisted at a different cwd (persisted: ${String(stored.meta.cwd)}, live: ${String(session.header.cwd)}) (id collision)`);
+			if (stored.inheritedEventCount !== session.inheritedEventCount) throw new Error(`session "${id}" is already persisted with a different inherited event count (id collision)`);
+			assertVersion(stored.meta);
+			repairReadView(stored.events);
+			const seed = session.snapshotEvents();
+			if (!seedCoversPrefix(seed, stored.events)) throw new Error(`session "${id}" already has a persisted log on disk that does not match this live session (id collision)`);
+			handle = await this.open(id, "write");
+			const suffix = seed.slice(stored.events.length);
+			if (suffix.length > 0) await handle.append(suffix);
+		}
+		const buffered = this.liveBuffers.get(id);
+		if (buffered !== void 0 && buffered.length > 0) {
+			this.liveBuffers.set(id, []);
+			for (const event of buffered) handle.enqueueLive(event, () => {});
+		}
+	}
+};
+function seedCoversPrefix(seed, prefix) {
+	return prefix.length <= seed.length && prefix.every((event, index) => {
+		const seedEvent = seed[index];
+		return seedEvent !== void 0 && JSON.stringify(seedEvent) === JSON.stringify(event);
+	});
+}
+function createBackend(config) {
+	if (config.type === "sqlite") return new SqliteBackend({
+		path: config.path,
+		journalMode: config.journalMode ?? "wal",
+		busyTimeout: config.busyTimeout ?? 5e3
+	});
+	const pool = new Pool({ connectionString: config.connectionString });
+	pool.on("error", () => {});
+	return new PostgresBackend(drizzle({ client: pool }), {
+		identityBase: [
+			"postgres",
+			pool.options.host ?? "localhost",
+			String(pool.options.port ?? 5432),
+			pool.options.database ?? "",
+			config.schema ?? "public"
+		].join(":"),
+		schema: config.schema ?? "public",
+		close: () => pool.end()
+	});
+}
+async function appendEventTail(tx, meta, events, anchor, reuse) {
+	let parentId = anchor.parentId;
+	let nextSeq = anchor.nextSeq;
+	const eventRows = [];
+	const bridgeRows = [];
+	for (const event of events) {
+		const reusedId = reuse?.get(event.seq);
+		const eventId = reusedId ?? randomUUID();
+		if (reusedId === void 0) {
+			const { kind, role, name, actionId } = eventDimensions(event);
+			const { data, surfaceOp: _surfaceOp, sourceEventSeqs: _sourceEventSeqs, ...envelope } = event;
+			eventRows.push({
+				fEventId: eventId,
+				fParentId: parentId,
+				fType: event.type,
+				fKind: kind,
+				fRole: role,
+				fName: name,
+				fActionId: actionId,
+				fEncoding: EVENT_ENCODING,
+				fData: JSON.stringify({
+					...envelope,
+					data
+				}),
+				fCreatedAt: event.time
+			});
+		}
+		const surfaceOp = event.surfaceOp === void 0 ? null : JSON.stringify(event.surfaceOp);
+		bridgeRows.push({
+			fSessionId: meta.id,
+			fEventId: eventId,
+			fSequence: nextSeq,
+			fSurfaceOp: surfaceOp
+		});
+		parentId = eventId;
+		nextSeq++;
+	}
+	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
+	};
+}
+//#endregion
+export { registerSessionDeletion as i, SessionPersistenceRdb as n, SESSION_DELETE_PATH as r, SessionDeletionError as t };