@morlay/session-rdb 0.0.11 → 0.0.12

package/dist/index.mjs

@@ -0,0 +1,2030 @@
+import z from "@deepseek-ai/schemastery";
+import { randomUUID } from "node:crypto";
+import { Pool } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { PersistenceCoordinator, SessionPersistence, SessionPersistenceRevision } from "@deepseek-ai/dsh-session-persistence";
+import { SESSION_FORMAT_VERSION, SessionLogOffset, SessionSeq, decodeSeqRanges, decodeStorageRecord, encodeSeqRanges, packChunkRuns } from "@deepseek-ai/dsh-session";
+import { and, desc, eq, gte, 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 { statSync } from "node:fs";
+import { mkdir, open } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { drizzle as drizzle$1 } from "drizzle-orm/node-sqlite";
+import { SessionBranch, SessionBranchError, balanceRewindPrefix, buildTimeline } from "@morlay/session-branch";
+import { unzipSync } from "fflate";
+//#region src/write-guard.ts
+var WriteGuard = class {
+	headSeqs = /* @__PURE__ */ new Map();
+	confirmHead(id, head) {
+		this.headSeqs.set(id, head);
+	}
+	assertNoConcurrentWriter(id, storedHead) {
+		const known = this.headSeqs.get(id);
+		if (known === void 0) {
+			if (storedHead !== -1) throw new Error(`session "${id}" has a persisted log this instance has not read; another writer may own it — load the session first`);
+			return;
+		}
+		if (known !== storedHead) throw new Error(`session "${id}" was modified by another writer (stored head ${storedHead}, this instance last confirmed head ${known}); concurrent writers on one session are not supported`);
+	}
+};
+//#endregion
+//#region src/log.ts
+function rowToMeta(row) {
+	if (!Number.isSafeInteger(row.fCreatedAt) || row.fCreatedAt < 0) throw new Error("stored session createdAt must be a non-negative safe integer");
+	return {
+		version: row.fVersion,
+		id: row.fSessionId,
+		createdAt: row.fCreatedAt,
+		...row.fCwd !== null ? { cwd: row.fCwd } : {},
+		...row.fParentSession !== null ? { parentSession: row.fParentSession } : {},
+		isSeeded: row.fSeedLength !== null,
+		...row.fOrigin !== null ? { origin: row.fOrigin } : {},
+		...row.fDelegationDepth === null ? {} : { delegationDepth: row.fDelegationDepth }
+	};
+}
+function sessionInsertRow(storage, incarnation) {
+	const meta = storage.meta;
+	return {
+		fSessionId: meta.id,
+		fHeadEventId: "",
+		fHeadSequence: -1,
+		fVersion: meta.version,
+		fCreatedAt: meta.createdAt,
+		fCwd: meta.cwd ?? null,
+		fParentSession: meta.parentSession ?? null,
+		fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+		fOrigin: meta.origin ?? null,
+		fDelegationDepth: meta.delegationDepth ?? null,
+		fIncarnation: incarnation,
+		fRevision: 0
+	};
+}
+function sessionConflictRow(storage) {
+	const meta = storage.meta;
+	return {
+		fVersion: meta.version,
+		fCreatedAt: meta.createdAt,
+		fCwd: meta.cwd ?? null,
+		fParentSession: meta.parentSession ?? null,
+		fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+		fOrigin: meta.origin ?? null,
+		fDelegationDepth: meta.delegationDepth ?? null
+	};
+}
+function remapSurfaceOp(op, remap) {
+	if (op === "append") return op;
+	return {
+		op: "replace",
+		start: SessionSeq(remap(op.start)),
+		end: SessionSeq(remap(op.end))
+	};
+}
+function remapShadowedRange(range, remap) {
+	return {
+		start: remap(range.start),
+		end: remap(range.end)
+	};
+}
+function rowToEvent(row, seqMap) {
+	const remap = (seq) => seqMap.get(seq) ?? seq;
+	const surfaceOp = row.fSurfaceOp !== null ? remapSurfaceOp(JSON.parse(row.fSurfaceOp), remap) : void 0;
+	const data = JSON.parse(row.fData);
+	if (row.fType === "compaction/summary" || row.fType === "compaction/prune") {
+		const metering = data;
+		if (metering.shadowedRange !== void 0) metering.shadowedRange = remapShadowedRange(metering.shadowedRange, remap);
+	}
+	return {
+		type: row.fType,
+		seq: row.fSequence,
+		time: row.fCreatedAt,
+		data,
+		...surfaceOp === void 0 ? {} : { surfaceOp }
+	};
+}
+function buildSeqMap(rows) {
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) if (!map.has(row.fOriginalSeq)) map.set(row.fOriginalSeq, row.fSequence);
+	return map;
+}
+const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"user/message",
+	"assistant/message",
+	"tool/result"
+]);
+function recomputeReplaceProvenance(events) {
+	for (const event of events) {
+		const raw = event;
+		const op = raw.surfaceOp;
+		if (typeof op !== "object" || op === null || op.op !== "replace") continue;
+		const { start, end } = op;
+		const refs = [];
+		for (const candidate of events) if (candidate.seq >= start && candidate.seq <= end && SURFACE_EVENT_TYPES.has(candidate.type)) refs.push(candidate.seq);
+		raw.sourceEventSeqs = refs;
+	}
+}
+function isEventSeqLike(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0);
+}
+function isDeepEqualJson(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((item, i) => isDeepEqualJson(item, b[i]));
+	}
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	const aKeys = Object.keys(a);
+	const bRecord = b;
+	if (aKeys.length !== Object.keys(bRecord).length) return false;
+	return aKeys.every((key) => Object.hasOwn(bRecord, key) && isDeepEqualJson(a[key], bRecord[key]));
+}
+function toolResultRewriteContentOnly(original, replacement) {
+	const originalData = original.data;
+	const replacementData = replacement.data;
+	const originalMessage = originalData["message"];
+	const replacementMessage = replacementData["message"];
+	const originalContent = Array.isArray(originalMessage?.content) ? originalMessage.content : void 0;
+	const replacementContent = Array.isArray(replacementMessage?.content) ? replacementMessage.content : void 0;
+	if (originalContent === void 0 || replacementContent === void 0) return false;
+	return isDeepEqualJson({
+		...originalData,
+		message: {
+			...originalMessage,
+			content: [{
+				...originalContent[0],
+				content: null
+			}]
+		}
+	}, {
+		...replacementData,
+		message: {
+			...replacementMessage,
+			content: [{
+				...replacementContent[0],
+				content: null
+			}]
+		}
+	});
+}
+function findSurfaceRepairs(events) {
+	const nodes = [];
+	const degradeToAppend = /* @__PURE__ */ new Set();
+	const addAppendMarker = /* @__PURE__ */ new Set();
+	const clearSurfaceOp = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		const op = event.surfaceOp;
+		if (op === void 0) {
+			if (SURFACE_EVENT_TYPES.has(event.type)) {
+				addAppendMarker.add(event.seq);
+				nodes.push(event.seq);
+			}
+			continue;
+		}
+		if (op === "append") {
+			if (SURFACE_EVENT_TYPES.has(event.type)) nodes.push(event.seq);
+			else clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		if (!SURFACE_EVENT_TYPES.has(event.type)) {
+			clearSurfaceOp.add(event.seq);
+			continue;
+		}
+		const replace = typeof op === "object" && op !== null && !Array.isArray(op) ? op : void 0;
+		const start = replace?.["start"];
+		const end = replace?.["end"];
+		const shapeOk = replace !== void 0 && replace["op"] === "replace" && isEventSeqLike(start) && isEventSeqLike(end);
+		const startIdx = shapeOk ? nodes.indexOf(start) : -1;
+		const endIdx = shapeOk ? nodes.indexOf(end) : -1;
+		const rangeOk = shapeOk && startIdx !== -1 && endIdx !== -1 && startIdx <= endIdx;
+		let rewriteOk = true;
+		if (rangeOk && event.type === "tool/result") {
+			const shadowed = nodes.slice(startIdx, endIdx + 1);
+			if (shadowed.length !== 1) rewriteOk = false;
+			else {
+				const original = events[shadowed[0]];
+				rewriteOk = original?.type === "tool/result" && toolResultRewriteContentOnly(original, event);
+			}
+		}
+		if (!rangeOk || !rewriteOk) {
+			degradeToAppend.add(event.seq);
+			nodes.push(event.seq);
+			continue;
+		}
+		nodes.splice(startIdx, endIdx - startIdx + 1, event.seq);
+	}
+	return {
+		degradeToAppend,
+		addAppendMarker,
+		clearSurfaceOp
+	};
+}
+function repairSurfaceOps(events) {
+	const repairs = findSurfaceRepairs(events);
+	if (repairs.degradeToAppend.size === 0 && repairs.addAppendMarker.size === 0 && repairs.clearSurfaceOp.size === 0) return;
+	for (const event of events) {
+		const raw = event;
+		if (repairs.degradeToAppend.has(event.seq)) raw.surfaceOp = "append";
+		else if (repairs.addAppendMarker.has(event.seq)) raw.surfaceOp = "append";
+		else if (repairs.clearSurfaceOp.has(event.seq)) delete raw.surfaceOp;
+	}
+}
+function scanRows(rows, base = 0, seqMap = /* @__PURE__ */ new Map()) {
+	const parsed = rows.map((row) => {
+		try {
+			return {
+				ok: true,
+				event: rowToEvent(row, seqMap)
+			};
+		} catch {
+			return { ok: false };
+		}
+	});
+	let lastTurnEnd = -1;
+	for (let i = parsed.length - 1; i >= 0; i--) if (parsed[i]?.ok && rows[i]?.fType === "turn/end") {
+		lastTurnEnd = i;
+		break;
+	}
+	const preserved = [];
+	for (let i = 0; i < rows.length; i++) {
+		const p = parsed[i];
+		if (!p?.ok || p.event === void 0) {
+			if (i <= lastTurnEnd) throw new Error(`corrupt session log: unparsable committed event at seq ${rows[i]?.fSequence}`);
+			break;
+		}
+		if (p.event.seq !== base + i) {
+			if (i <= lastTurnEnd) throw new Error(`corrupt session log: seq gap in committed region (expected ${base + i}, got ${p.event.seq})`);
+			break;
+		}
+		preserved.push(p.event);
+	}
+	return preserved.length < rows.length ? {
+		preserved,
+		tornFrom: base + preserved.length
+	} : { preserved };
+}
+function toStorageRecord(record) {
+	const withSeqs = record;
+	if (withSeqs.sourceEventSeqs === void 0) return record;
+	return {
+		...record,
+		sourceEventSeqs: encodeSeqRanges(withSeqs.sourceEventSeqs)
+	};
+}
+function toJsonlArtifact(meta, inheritedEventCount, events) {
+	const header = {
+		type: "session",
+		version: meta.version,
+		id: meta.id,
+		createdAt: meta.createdAt,
+		...meta.cwd === void 0 ? {} : { cwd: meta.cwd },
+		...meta.parentSession === void 0 ? {} : { parentSession: meta.parentSession },
+		...meta.isSeeded ? { seedLength: inheritedEventCount } : {},
+		...meta.origin === void 0 ? {} : { origin: meta.origin },
+		delegationDepth: meta.delegationDepth ?? 0,
+		...meta.agentPreset === void 0 ? {} : { agentPreset: meta.agentPreset }
+	};
+	const lines = [JSON.stringify(header)];
+	for (const record of packChunkRuns(events)) lines.push(JSON.stringify(toStorageRecord(record)));
+	return lines.join("\n");
+}
+//#endregion
+//#region src/entities/types.ts
+function toProperty(name) {
+	return name.replace(/_([a-z])/g, (_match, char) => char.toUpperCase());
+}
+//#endregion
+//#region src/adapters/to-sqlite.ts
+function buildColumn$1(c, tables) {
+	let col;
+	switch (c.type) {
+		case "text":
+			col = text(c.name);
+			break;
+		case "serial":
+			col = integer(c.name).primaryKey({ autoIncrement: true });
+			break;
+		case "integer":
+		case "bigint": {
+			const built = integer(c.name);
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+	}
+	if (c.notNull) col = col.notNull();
+	if (c.default !== void 0) col = col.default(c.default);
+	if (c.unique) col = col.unique();
+	if (c.references) {
+		const { table, column, onDelete } = c.references;
+		col = col.references(() => tables[table][toProperty(column)], { onDelete });
+	}
+	return col;
+}
+function toSqliteSchema(defs) {
+	const tables = {};
+	for (const def of defs) {
+		const columns = {};
+		for (const c of def.columns) columns[toProperty(c.name)] = buildColumn$1(c, tables);
+		const extra = (self) => [
+			...(def.checks ?? []).map((c) => check(c.name, sql.raw(c.expression))),
+			...(def.uniques ?? []).map((u) => unique(u.name).on(...u.columns.map((name) => self[toProperty(name)]))),
+			...(def.indexes ?? []).map((i) => index(i.name).on(...i.columns.map((name) => self[toProperty(name)])))
+		];
+		tables[def.name] = sqliteTable(def.name, columns, extra);
+	}
+	return tables;
+}
+//#endregion
+//#region src/adapters/to-postgres.ts
+function buildColumn(c, tables) {
+	let col;
+	switch (c.type) {
+		case "text":
+			col = text$1(c.name);
+			break;
+		case "serial":
+			col = serial(c.name).primaryKey();
+			break;
+		case "integer": {
+			const built = integer$1(c.name);
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+		case "bigint": {
+			const built = bigint(c.name, { mode: "number" });
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+	}
+	if (c.notNull) col = col.notNull();
+	if (c.default !== void 0) col = col.default(c.default);
+	if (c.unique) col = col.unique();
+	if (c.references) {
+		const { table, column, onDelete } = c.references;
+		col = col.references(() => tables[table][toProperty(column)], { onDelete });
+	}
+	return col;
+}
+function toPostgresSchema(defs, schemaName = "public") {
+	const tables = {};
+	const table = schemaName === "public" ? pgTable : pgSchema(schemaName).table;
+	for (const def of defs) {
+		const columns = {};
+		for (const c of def.columns) columns[toProperty(c.name)] = buildColumn(c, tables);
+		const extra = (self) => [
+			...(def.checks ?? []).map((c) => check$1(c.name, sql.raw(c.expression))),
+			...(def.uniques ?? []).map((u) => unique$1(u.name).on(...u.columns.map((name) => self[toProperty(name)]))),
+			...(def.indexes ?? []).map((i) => index$1(i.name).on(...i.columns.map((name) => self[toProperty(name)])))
+		];
+		tables[def.name] = table(def.name, columns, extra);
+	}
+	return tables;
+}
+//#endregion
+//#region src/adapters/ddl.ts
+function sqlType(dialect, type) {
+	switch (type) {
+		case "serial": return dialect === "sqlite" ? "INTEGER" : "SERIAL";
+		case "integer": return "INTEGER";
+		case "bigint": return dialect === "sqlite" ? "INTEGER" : "BIGINT";
+		case "text": return "TEXT";
+	}
+}
+function literal(value) {
+	return typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : String(value);
+}
+function quote(name) {
+	return `"${name}"`;
+}
+function columnSql(dialect, c) {
+	let sql = `${quote(c.name)} ${sqlType(dialect, c.type)}`;
+	if (c.primaryKey) sql += " PRIMARY KEY";
+	if (c.type === "serial" && dialect === "sqlite") sql += " AUTOINCREMENT";
+	if (c.notNull) sql += " NOT NULL";
+	if (c.default !== void 0) sql += ` DEFAULT ${literal(c.default)}`;
+	if (c.unique) sql += " UNIQUE";
+	if (c.references) {
+		sql += ` REFERENCES ${quote(c.references.table)}(${quote(c.references.column)})`;
+		if (c.references.onDelete) sql += ` ON DELETE ${c.references.onDelete.toUpperCase()}`;
+	}
+	return sql;
+}
+function createTableSql(dialect, def, schema) {
+	const parts = def.columns.map((c) => columnSql(dialect, c));
+	for (const ck of def.checks ?? []) parts.push(`CHECK (${ck.expression})`);
+	for (const u of def.uniques ?? []) parts.push(`UNIQUE (${u.columns.map(quote).join(", ")})`);
+	const strict = dialect === "sqlite" ? " STRICT" : "";
+	return `CREATE TABLE IF NOT EXISTS ${schema === void 0 || schema === "public" ? quote(def.name) : `${quote(schema)}.${quote(def.name)}`} (\n  ${parts.join(",\n  ")}\n)${strict}`;
+}
+function createIndexSql(def, name, schema) {
+	const idx = def.indexes?.find((i) => i.name === name);
+	if (idx === void 0) throw new Error(`unknown index "${name}" on table "${def.name}"`);
+	const qualified = schema === void 0 || schema === "public" ? quote(def.name) : `${quote(schema)}.${quote(def.name)}`;
+	return `CREATE INDEX IF NOT EXISTS ${quote(idx.name)} ON ${qualified}(${idx.columns.map(quote).join(", ")})`;
+}
+function createTablesSql(dialect, defs, schema) {
+	const statements = [];
+	for (const def of defs) {
+		statements.push(createTableSql(dialect, def, schema));
+		for (const idx of def.indexes ?? []) statements.push(createIndexSql(def, idx.name, schema));
+	}
+	return statements;
+}
+//#endregion
+//#region src/entities/persistence-state.ts
+const persistenceState = {
+	name: "t_persistence_state",
+	columns: [{
+		name: "f_singleton",
+		type: "integer",
+		primaryKey: true
+	}, {
+		name: "f_store_id",
+		type: "text",
+		notNull: true
+	}],
+	checks: [{
+		name: "ck_persistence_state_singleton",
+		expression: "f_singleton = 1"
+	}]
+};
+//#endregion
+//#region src/entities/schema-meta.ts
+const schemaMeta = {
+	name: "t_schema_meta",
+	columns: [{
+		name: "f_key",
+		type: "text",
+		primaryKey: true
+	}, {
+		name: "f_value",
+		type: "text",
+		notNull: true
+	}]
+};
+//#endregion
+//#region src/entities/sessions.ts
+const sessions = {
+	name: "t_sessions",
+	columns: [
+		{
+			name: "f_id",
+			type: "serial",
+			primaryKey: true
+		},
+		{
+			name: "f_session_id",
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		{
+			name: "f_head_event_id",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_head_sequence",
+			type: "integer",
+			notNull: true,
+			default: -1
+		},
+		{
+			name: "f_version",
+			type: "integer",
+			notNull: true
+		},
+		{
+			name: "f_created_at",
+			type: "bigint",
+			notNull: true
+		},
+		{
+			name: "f_cwd",
+			type: "text"
+		},
+		{
+			name: "f_parent_session",
+			type: "text"
+		},
+		{
+			name: "f_seed_length",
+			type: "integer"
+		},
+		{
+			name: "f_origin",
+			type: "text"
+		},
+		{
+			name: "f_delegation_depth",
+			type: "integer"
+		},
+		{
+			name: "f_incarnation",
+			type: "text",
+			notNull: true
+		},
+		{
+			name: "f_revision",
+			type: "integer",
+			notNull: true
+		}
+	]
+};
+//#endregion
+//#region src/entities/events.ts
+const events = {
+	name: "t_events",
+	columns: [
+		{
+			name: "f_id",
+			type: "serial",
+			primaryKey: true
+		},
+		{
+			name: "f_event_id",
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		{
+			name: "f_parent_id",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_type",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_kind",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_role",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_name",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_action_id",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_encoding",
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		{
+			name: "f_data",
+			type: "text",
+			notNull: true
+		},
+		{
+			name: "f_created_at",
+			type: "bigint",
+			notNull: true,
+			default: 0
+		}
+	],
+	indexes: [
+		{
+			name: "idx_events_kind",
+			columns: ["f_kind"]
+		},
+		{
+			name: "idx_events_role",
+			columns: ["f_role"]
+		},
+		{
+			name: "idx_events_name",
+			columns: ["f_name"]
+		},
+		{
+			name: "idx_events_action_id",
+			columns: ["f_action_id"]
+		}
+	]
+};
+//#endregion
+//#region src/entities/session-events.ts
+const sessionEvents = {
+	name: "t_session_events",
+	columns: [
+		{
+			name: "f_id",
+			type: "serial",
+			primaryKey: true
+		},
+		{
+			name: "f_session_id",
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		{
+			name: "f_event_id",
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_events",
+				column: "f_event_id",
+				onDelete: "cascade"
+			}
+		},
+		{
+			name: "f_sequence",
+			type: "integer",
+			notNull: true
+		},
+		{
+			name: "f_original_seq",
+			type: "integer",
+			notNull: true
+		},
+		{
+			name: "f_surface_op",
+			type: "text"
+		}
+	],
+	uniques: [{
+		name: "uq_session_events_session_sequence",
+		columns: ["f_session_id", "f_sequence"]
+	}],
+	indexes: [{
+		name: "idx_session_events_event_id",
+		columns: ["f_event_id"]
+	}]
+};
+//#endregion
+//#region src/entities/index.ts
+const sqliteTableDefs = [
+	persistenceState,
+	sessions,
+	events,
+	sessionEvents
+];
+const postgresTableDefs = [
+	persistenceState,
+	schemaMeta,
+	sessions,
+	events,
+	sessionEvents
+];
+//#endregion
+//#region src/schema.ts
+const SCHEMA_VERSION = 2;
+const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+const EPHEMERAL_EVENT_TYPES = ["assistant/chunk"];
+const EVENT_ENCODING = "json";
+const sqliteTables = toSqliteSchema(sqliteTableDefs);
+const tPersistenceState = sqliteTables["t_persistence_state"];
+const tSessions = sqliteTables["t_sessions"];
+const tEvents = sqliteTables["t_events"];
+const tSessionEvents = sqliteTables["t_session_events"];
+const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+function isEphemeralType(type) {
+	return EPHEMERAL_EVENT_TYPES.includes(type);
+}
+function isPersistedEvent(event) {
+	return !isEphemeralType(event.type) && event.ignorable !== true;
+}
+function eventKind(event) {
+	switch (event.type) {
+		case "user/message": return "message";
+		case "assistant/message":
+			if ((event.data.message?.content)?.some((block) => block?.type === "reasoning")) return "thinking";
+			return "message";
+		case "turn/start":
+		case "turn/end":
+		case "step/start":
+		case "step/end":
+		case "session/end-seed": return "turn";
+		case "tool/call":
+		case "tool/result":
+		case "tool/code-dispatch-start":
+		case "tool/code-dispatch": return "tool";
+		case "request/header":
+		case "request/context": return "request";
+		case "model/selection":
+		case "permission/preset":
+		case "approval/policy":
+		case "sandbox/mode":
+		case "plan/mode":
+		case "agent-preset/selected": return "config";
+		case "approval/asked":
+		case "approval/decided":
+		case "command/run":
+		case "command/done":
+		case "hook/invoked":
+		case "hook/result":
+		case "feedback/record": return "audit";
+		case "session/title":
+		case "session/title-llm-request":
+		case "session-log-deepseek/delivery-accepted": return "lifecycle";
+		case "agent/inbox/spliced": return "inbox";
+		case "compaction/start":
+		case "compaction/end":
+		case "compaction/summary":
+		case "compaction/prune": return "compaction";
+		case "llm/retry":
+		case "llm/retry-started": return "llm";
+		case "subagent/descriptor":
+		case "subagent/model-selection-policy": return "subagent";
+		case "team/member":
+		case "team/task":
+		case "team/message/queued":
+		case "team/message/delivered": return "team";
+		case "tool-workflow/run-start":
+		case "tool-workflow/run-end":
+		case "tool-workflow/agent-start":
+		case "tool-workflow/agent-end": return "workflow";
+		case "goal/change": return "goal";
+		case "schedule/change": return "schedule";
+		case "todo/write": return "todo";
+		case "web/deepseek-search-llm-request": return "web";
+		default: return "";
+	}
+}
+function eventDimensions(event) {
+	const kind = eventKind(event);
+	const type = event.type;
+	const data = event.data;
+	switch (type) {
+		case "user/message": return {
+			kind,
+			role: "user",
+			name: "",
+			actionId: ""
+		};
+		case "assistant/message": return {
+			kind,
+			role: "assistant",
+			name: "",
+			actionId: ""
+		};
+		case "tool/result": return {
+			kind,
+			role: "tool",
+			name: "",
+			actionId: data["message"]?.content?.[0]?.toolCallId ?? ""
+		};
+		case "tool/call": return {
+			kind,
+			role: "",
+			name: typeof data["name"] === "string" ? data["name"] : "",
+			actionId: typeof data["callId"] === "string" ? data["callId"] : ""
+		};
+		case "tool/code-dispatch-start":
+		case "tool/code-dispatch": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["subCallId"] === "string" ? data["subCallId"] : ""
+		};
+		case "command/run":
+		case "command/done": return {
+			kind,
+			role: "",
+			name: type === "command/run" && typeof data["name"] === "string" ? data["name"] : "",
+			actionId: typeof data["commandId"] === "string" ? data["commandId"] : ""
+		};
+		case "approval/asked":
+		case "approval/decided": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["id"] === "string" ? data["id"] : ""
+		};
+		case "hook/invoked":
+		case "hook/result": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["handlerId"] === "string" ? data["handlerId"] : ""
+		};
+		case "llm/retry":
+		case "llm/retry-started": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["retryId"] === "string" ? data["retryId"] : ""
+		};
+		case "tool-workflow/run-start":
+		case "tool-workflow/run-end":
+		case "tool-workflow/agent-start":
+		case "tool-workflow/agent-end": return {
+			kind,
+			role: "",
+			name: "",
+			actionId: typeof data["runId"] === "string" ? data["runId"] : ""
+		};
+		case "todo/write": return {
+			kind,
+			role: "",
+			name: "todos",
+			actionId: ""
+		};
+		case "subagent/descriptor": return {
+			kind,
+			role: "",
+			name: typeof data["label"] === "string" ? data["label"] : "",
+			actionId: ""
+		};
+		default: return {
+			kind,
+			role: "",
+			name: "",
+			actionId: ""
+		};
+	}
+}
+function migrateSqliteV1ToV2(db) {
+	const { user_version: onDisk } = db.prepare("PRAGMA user_version").get();
+	if (onDisk === 2) return 0;
+	if (onDisk !== 1) throw new Error(`unsupported schema version ${onDisk} (expected 1)`);
+	db.exec(`
+    CREATE TABLE t_events_v2 (
+      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      f_event_id TEXT NOT NULL UNIQUE,
+      f_parent_id TEXT NOT NULL DEFAULT '',
+      f_type TEXT NOT NULL DEFAULT '',
+      f_kind TEXT NOT NULL DEFAULT '',
+      f_role TEXT NOT NULL DEFAULT '',
+      f_name TEXT NOT NULL DEFAULT '',
+      f_action_id TEXT NOT NULL DEFAULT '',
+      f_encoding TEXT NOT NULL DEFAULT '',
+      f_data TEXT NOT NULL,
+      f_created_at INTEGER NOT NULL DEFAULT 0
+    ) STRICT;
+    CREATE TABLE t_session_events_v2 (
+      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      f_session_id TEXT NOT NULL REFERENCES t_sessions(f_session_id) ON DELETE CASCADE,
+      f_event_id TEXT NOT NULL REFERENCES t_events_v2(f_event_id) ON DELETE CASCADE,
+      f_sequence INTEGER NOT NULL,
+      f_original_seq INTEGER NOT NULL,
+      f_surface_op TEXT,
+      UNIQUE (f_session_id, f_sequence)
+    ) STRICT;
+    CREATE INDEX idx_events_v2_kind ON t_events_v2(f_kind);
+    CREATE INDEX idx_events_v2_role ON t_events_v2(f_role);
+    CREATE INDEX idx_events_v2_name ON t_events_v2(f_name);
+    CREATE INDEX idx_events_v2_action_id ON t_events_v2(f_action_id);
+    CREATE INDEX idx_session_events_v2_event_id ON t_session_events_v2(f_event_id);
+  `);
+	const oldEvents = db.prepare(`SELECT f_event_id, f_parent_id, f_kind, f_data, f_created_at FROM t_events ORDER BY f_id`).all();
+	const insertEvent = db.prepare(`
+    INSERT INTO t_events_v2
+      (f_event_id, f_parent_id, f_type, f_kind, f_role, f_name, f_action_id, f_encoding, f_data, f_created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'json', ?, ?)
+  `);
+	for (const row of oldEvents) {
+		let data;
+		try {
+			data = JSON.parse(row.f_data);
+		} catch {
+			throw new Error(`t_events row ${row.f_event_id} has unparsable f_data; aborting`);
+		}
+		const dims = eventDimensions({
+			type: row.f_kind,
+			seq: 0,
+			time: row.f_created_at,
+			data
+		});
+		insertEvent.run(row.f_event_id, row.f_parent_id, row.f_kind, dims.kind, dims.role, dims.name, dims.actionId, row.f_data, row.f_created_at);
+	}
+	const oldBridges = db.prepare(`SELECT se.f_session_id, se.f_event_id, se.f_sequence
+       FROM t_session_events se ORDER BY se.f_id`).all();
+	const oldEventMeta = new Map(db.prepare(`SELECT f_event_id, f_original_seq, f_surface_op FROM t_events`).all().map((row) => [row.f_event_id, row]));
+	const insertBridge = db.prepare(`
+    INSERT INTO t_session_events_v2
+      (f_session_id, f_event_id, f_sequence, f_original_seq, f_surface_op)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+	for (const row of oldBridges) {
+		const meta = oldEventMeta.get(row.f_event_id);
+		if (meta === void 0) throw new Error(`bridge row ${row.f_session_id}:${row.f_sequence} references missing event ${row.f_event_id}`);
+		insertBridge.run(row.f_session_id, row.f_event_id, row.f_sequence, meta.f_original_seq, meta.f_surface_op);
+	}
+	db.exec(`
+    DROP TABLE t_session_events;
+    DROP TABLE t_events;
+    ALTER TABLE t_events_v2 RENAME TO t_events;
+    ALTER TABLE t_session_events_v2 RENAME TO t_session_events;
+  `);
+	db.exec(`PRAGMA user_version = 2`);
+	return oldEvents.length;
+}
+//#endregion
+//#region src/sqlite.ts
+const sqliteTxQueues = /* @__PURE__ */ new Map();
+function enqueueSqliteTx(path, fn) {
+	const run = (sqliteTxQueues.get(path) ?? Promise.resolve()).then(fn);
+	sqliteTxQueues.set(path, run.then(() => void 0, () => void 0));
+	return run;
+}
+async function createDatabaseFile(path) {
+	try {
+		await (await open(path, "wx", 384)).close();
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+	}
+}
+function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOUT_MS) {
+	const db = new DatabaseSync(path);
+	try {
+		configureDatabase(db, path, journalMode, busyTimeout);
+		return db;
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+}
+function configureDatabase(db, path, journalMode, busyTimeout) {
+	db.exec("PRAGMA foreign_keys = ON");
+	db.exec(`PRAGMA busy_timeout = ${busyTimeout}`);
+	drizzle$1({ client: db }).transaction((tx) => {
+		const { user_version: onDisk } = tx.get(sql`PRAGMA user_version`);
+		const { application_id: applicationId } = tx.get(sql`PRAGMA application_id`);
+		const { count: userObjectCount } = tx.get(sql`SELECT COUNT(*) AS count FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*'`);
+		if (onDisk === 0 && (applicationId !== 0 || userObjectCount > 0)) throw new Error(`session database at "${path}" has an unversioned schema or application identity`);
+		if (onDisk === 1) migrateSqliteV1ToV2(db);
+		else if (onDisk !== 0 && onDisk !== 2) throw new Error(`session database at "${path}" has schema version ${onDisk}, incompatible with this build (2)`);
+		if ((onDisk === 2 || onDisk === 1) && applicationId !== 1146308688) throw new Error(`session database at "${path}" has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
+		for (const statement of createTablesSql("sqlite", sqliteTableDefs)) tx.run(sql.raw(statement));
+		tx.insert(tPersistenceState).values({
+			fSingleton: 1,
+			fStoreId: randomUUID()
+		}).onConflictDoNothing().run();
+		if (onDisk === 0) {
+			tx.run(sql.raw(`PRAGMA application_id = ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`));
+			tx.run(sql.raw(`PRAGMA user_version = 2`));
+		}
+	}, { behavior: "immediate" });
+	db.exec(`PRAGMA journal_mode = ${journalMode.toUpperCase()}`);
+}
+var SqliteBackend = class SqliteBackend {
+	options;
+	kind = "sqlite";
+	storeIdentity;
+	dbPath = "";
+	db;
+	constructor(options) {
+		this.options = options;
+	}
+	async open() {
+		const actual = this.options.path === ":memory:" ? this.options.path : resolve(this.options.path);
+		this.dbPath = actual;
+		if (actual !== ":memory:") {
+			await mkdir(dirname(actual), {
+				recursive: true,
+				mode: 448
+			});
+			await createDatabaseFile(actual);
+		}
+		await enqueueSqliteTx(actual, async () => {
+			this.db = drizzle$1({ client: openDatabase(actual, this.options.journalMode, this.options.busyTimeout) });
+		});
+		try {
+			const row = this.db.select({ fStoreId: tPersistenceState.fStoreId }).from(tPersistenceState).where(eq(tPersistenceState.fSingleton, 1)).get();
+			/* v8 ignore next -- openDatabase inserts the singleton before returning. */
+			if (row === void 0) throw new Error(`session database at "${actual}" has no store identity`);
+			if (row.fStoreId.length === 0) throw new Error(`session database at "${actual}" has no valid store identity`);
+			if (actual !== ":memory:") {
+				const identity = statSync(actual, { bigint: true });
+				this.storeIdentity = `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${row.fStoreId}`;
+			} else this.storeIdentity = `memory:store:${row.fStoreId}`;
+		} catch (error) {
+			this.db.$client.close();
+			throw error;
+		}
+	}
+	async close() {
+		if (this.db === void 0) return;
+		this.db.$client.close();
+	}
+	async getSession(id) {
+		return this.db.select().from(tSessions).where(eq(tSessions.fSessionId, id)).get();
+	}
+	async getSeqMapRows(id) {
+		return this.db.select({
+			fSequence: tSessionEvents.fSequence,
+			fOriginalSeq: tSessionEvents.fOriginalSeq
+		}).from(tSessionEvents).where(eq(tSessionEvents.fSessionId, id)).all();
+	}
+	async getEventRows(id, fromSequence) {
+		return (fromSequence === void 0 ? this.eventRows().where(eq(tSessionEvents.fSessionId, id)) : this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence)))).orderBy(tSessionEvents.fSequence).all();
+	}
+	async listSessions() {
+		return this.db.select().from(tSessions).all();
+	}
+	async transaction(fn) {
+		return enqueueSqliteTx(this.dbPath, async () => {
+			this.db.$client.exec("BEGIN IMMEDIATE");
+			try {
+				const result = await fn(this.tx);
+				this.db.$client.exec("COMMIT");
+				return result;
+			} catch (error) {
+				/* v8 ignore start */
+				try {
+					this.db.$client.exec("ROLLBACK");
+				} catch {}
+				throw error;
+			}
+		});
+	}
+	tx = {
+		upsertSession: (storage, incarnation) => this.upsertSession(storage, incarnation),
+		getHead: (id) => this.getHead(id),
+		getSeedLength: (id) => this.getSeedLength(id),
+		updateSeedLength: (id, seedLength) => this.updateSeedLength(id, seedLength),
+		insertEvents: (events) => this.insertEvents(events),
+		insertBridges: (rows) => this.insertBridges(rows),
+		updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
+		bumpRevision: (id) => this.bumpRevision(id),
+		deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
+		getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence),
+		getLastBridge: (id) => this.getLastBridge(id)
+	};
+	async upsertSession(storage, incarnation) {
+		this.db.insert(tSessions).values(sessionInsertRow(storage, incarnation)).onConflictDoUpdate({
+			target: tSessions.fSessionId,
+			set: sessionConflictRow(storage)
+		}).run();
+	}
+	async getHead(id) {
+		const head = this.db.select({
+			fHeadEventId: tSessions.fHeadEventId,
+			fHeadSequence: tSessions.fHeadSequence
+		}).from(tSessions).where(eq(tSessions.fSessionId, id)).get();
+		/* v8 ignore next -- appendBatch/commitRepair always materialize the row before reading the head */
+		if (head === void 0) throw new Error(`session "${id}" has no materialized row`);
+		return head;
+	}
+	async getSeedLength(id) {
+		const row = this.db.select({ fSeedLength: tSessions.fSeedLength }).from(tSessions).where(eq(tSessions.fSessionId, id)).get();
+		/* v8 ignore next -- rewind always materializes the row before reading the seed length */
+		if (row === void 0) throw new Error(`session "${id}" has no materialized row`);
+		return row.fSeedLength;
+	}
+	async updateSeedLength(id, seedLength) {
+		this.db.update(tSessions).set({ fSeedLength: seedLength }).where(eq(tSessions.fSessionId, id)).run();
+	}
+	static INSERT_BATCH_ROWS = 1e3;
+	async insertEvents(events) {
+		if (events.length === 0) return;
+		for (let i = 0; i < events.length; i += SqliteBackend.INSERT_BATCH_ROWS) this.db.insert(tEvents).values(events.slice(i, i + SqliteBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).run();
+	}
+	async insertBridges(rows) {
+		if (rows.length === 0) return;
+		for (let i = 0; i < rows.length; i += SqliteBackend.INSERT_BATCH_ROWS) this.db.insert(tSessionEvents).values(rows.slice(i, i + SqliteBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).run();
+	}
+	async updateHead(id, headEventId, headSequence) {
+		this.db.update(tSessions).set({
+			fHeadEventId: headEventId,
+			fHeadSequence: headSequence
+		}).where(eq(tSessions.fSessionId, id)).run();
+	}
+	async bumpRevision(id) {
+		this.db.update(tSessions).set({ fRevision: sql`${tSessions.fRevision} + 1` }).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();
+	}
+	async getPrevBridge(id, sequence) {
+		return this.db.select({
+			fEventId: tSessionEvents.fEventId,
+			fSequence: tSessionEvents.fSequence
+		}).from(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get();
+	}
+	async getLastBridge(id) {
+		return this.db.select({
+			fEventId: tSessionEvents.fEventId,
+			fSequence: tSessionEvents.fSequence
+		}).from(tSessionEvents).where(eq(tSessionEvents.fSessionId, id)).orderBy(desc(tSessionEvents.fSequence)).limit(1).get();
+	}
+	eventRows() {
+		return this.db.select({
+			fEventId: tSessionEvents.fEventId,
+			fSequence: tSessionEvents.fSequence,
+			fOriginalSeq: tSessionEvents.fOriginalSeq,
+			fType: tEvents.fType,
+			fKind: tEvents.fKind,
+			fRole: tEvents.fRole,
+			fName: tEvents.fName,
+			fActionId: tEvents.fActionId,
+			fCreatedAt: tEvents.fCreatedAt,
+			fData: tEvents.fData,
+			fSurfaceOp: tSessionEvents.fSurfaceOp
+		}).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId));
+	}
+};
+//#endregion
+//#region src/postgres.ts
+var PostgresBackend = class PostgresBackend {
+	db;
+	options;
+	kind = "postgres";
+	storeIdentity;
+	tables;
+	constructor(db, options) {
+		this.db = db;
+		this.options = options;
+		this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
+	}
+	async open() {
+		const storeId = await this.db.transaction(async (tx) => {
+			const schema = this.options.schema ?? "public";
+			const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
+			const metaExists = (await tx.execute(sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`)).rows[0]?.exists === true;
+			for (const statement of createTablesSql("postgres", postgresTableDefs, schema)) await tx.execute(sql.raw(statement));
+			if (!metaExists) await tx.insert(this.tables["t_schema_meta"]).values([{
+				fKey: "schema_version",
+				fValue: String(2)
+			}, {
+				fKey: "application_id",
+				fValue: String(SESSION_PERSISTENCE_SQLITE_APPLICATION_ID)
+			}]).execute();
+			const version = await this.readMeta(tx, "schema_version");
+			const applicationId = await this.readMeta(tx, "application_id");
+			if (version === void 0 || applicationId === void 0) throw new Error("session database has an unversioned schema or application identity");
+			if (Number(version) !== 2) throw new Error(`session database has schema version ${version}, incompatible with this build (2)`);
+			if (Number(applicationId) !== 1146308688) throw new Error(`session database has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
+			await tx.insert(this.tables["t_persistence_state"]).values({
+				fSingleton: 1,
+				fStoreId: randomUUID()
+			}).onConflictDoNothing().execute();
+			const storeId = (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 (storeId === void 0 || storeId.length === 0) throw new Error("session database has no valid store identity");
+			return storeId;
+		});
+		this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
+	}
+	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 getSeqMapRows(id) {
+		return this.db.select({
+			fSequence: this.tables["t_session_events"].fSequence,
+			fOriginalSeq: this.tables["t_session_events"].fOriginalSeq
+		}).from(this.tables["t_session_events"]).where(eq(this.tables["t_session_events"].fSessionId, id)).execute();
+	}
+	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 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),
+			deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
+			getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
+			getLastBridge: (id) => this.getLastBridge(tx, id)
+		};
+	}
+	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];
+		/* v8 ignore next -- appendBatch/commitRepair always materialize the row before reading the head */
+		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];
+		/* v8 ignore next -- rewind always materializes the row before reading the seed length */
+		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();
+	}
+	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 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 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];
+	}
+	async getLastBridge(exec, id) {
+		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(eq(this.tables["t_session_events"].fSessionId, id)).orderBy(desc(this.tables["t_session_events"].fSequence)).limit(1).execute())[0];
+	}
+	eventRows(exec) {
+		return exec.select({
+			fEventId: this.tables["t_session_events"].fEventId,
+			fSequence: this.tables["t_session_events"].fSequence,
+			fOriginalSeq: this.tables["t_session_events"].fOriginalSeq,
+			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/branch.ts
+function locateTurnEnd(events, atSeq, mode = "after") {
+	const ends = events.filter((event) => event.type === "turn/end").map((event) => event.seq);
+	if (atSeq === void 0) {
+		const last = ends.at(-1);
+		if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
+		return last;
+	}
+	if (mode === "before") {
+		let boundary = -1;
+		for (const seq of ends) if (seq < atSeq) boundary = seq;
+		else break;
+		return boundary;
+	}
+	const firstAfter = ends.find((seq) => seq >= atSeq);
+	if (firstAfter !== void 0) return firstAfter;
+	const lastStart = [...events].reverse().find((event) => event.type === "turn/start");
+	if (lastStart !== void 0 && lastStart.seq <= atSeq) throw new SessionBranchError(`anchor ${atSeq} lies inside an open turn`, "OPEN_TURN");
+	const last = ends.at(-1);
+	if (last === void 0) throw new SessionBranchError("session has no closed turn", "OPEN_TURN");
+	return last;
+}
+function renumber(events, offset) {
+	return events.map((event, index) => ({
+		...event,
+		seq: offset + index
+	}));
+}
+function mintSessionId() {
+	return `session-${randomUUID()}`;
+}
+function truncateLiveSession(session, newLength) {
+	const s = session;
+	s.log.length = newLength;
+	s.eventsSnapshot = void 0;
+	s.headerFold = void 0;
+	s.headerFoldSeq = 0;
+	s.contextFold = void 0;
+	s.contextFoldSeq = 0;
+	s.derived = [];
+	s.derivedNodes = 0;
+	s.derivedGeneration = 0;
+	s.surfaceManager._state = {
+		nodes: [],
+		replaceGeneration: 0
+	};
+	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
+	s.surfaceManager._pendingPlan = void 0;
+}
+function replaceLiveSessionLog(session, events) {
+	const s = session;
+	s.log.length = 0;
+	s.log.push(...events);
+	s.eventsSnapshot = void 0;
+	s.headerFold = void 0;
+	s.headerFoldSeq = 0;
+	s.contextFold = void 0;
+	s.contextFoldSeq = 0;
+	s.derived = [];
+	s.derivedNodes = 0;
+	s.derivedGeneration = 0;
+	s.surfaceManager._state = {
+		nodes: [],
+		replaceGeneration: 0
+	};
+	s.surfaceManager._lastProcessedSeq = s.surfaceManager.baseSeq - 1;
+	s.surfaceManager._pendingPlan = void 0;
+}
+var SessionBranchRdbProvider = class {
+	persistence;
+	live;
+	name = "session-rdb";
+	constructor(persistence, live = {
+		getSession: () => void 0,
+		getAgent: () => void 0,
+		flush: async () => true,
+		setCoordinatorCursor: () => {},
+		setCoordinatorState: () => {},
+		setCoordinatorSeedLength: () => {}
+	}) {
+		this.persistence = persistence;
+		this.live = live;
+	}
+	async readBranchPrefix(id, atSeq, mode = "after", signal) {
+		const { events } = await this.readRawEvents(id, signal);
+		const boundary = locateTurnEnd(events, atSeq, mode);
+		return {
+			seq: boundary,
+			events: events.slice(0, boundary + 1)
+		};
+	}
+	async readRawEvents(id, signal) {
+		const stored = await this.persistence.loadStored(id, signal);
+		if (stored === void 0) throw new SessionBranchError(`session "${id}" not found`, "SESSION_NOT_FOUND");
+		return {
+			meta: stored.meta,
+			events: stored.events
+		};
+	}
+	async forkFrom(sourceId, options = {}, signal) {
+		signal?.throwIfAborted();
+		const { atSeq, anchorMode = "after", seedSuffix = [], childSessionId, meta = {} } = options;
+		const source = await this.persistence.inspect(sourceId, signal);
+		const boundary = locateTurnEnd(source.events, atSeq, anchorMode);
+		const prefix = source.events.slice(0, boundary + 1);
+		const childId = childSessionId ?? mintSessionId();
+		const childMeta = {
+			version: SESSION_FORMAT_VERSION,
+			id: childId,
+			createdAt: meta.createdAt ?? Date.now(),
+			...meta.cwd !== void 0 ? { cwd: meta.cwd } : source.meta.cwd !== void 0 ? { cwd: source.meta.cwd } : {},
+			parentSession: sourceId,
+			isSeeded: true,
+			...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : source.meta.agentPreset !== void 0 ? { agentPreset: source.meta.agentPreset } : {},
+			...meta.origin !== void 0 ? { origin: meta.origin } : {},
+			...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {}
+		};
+		const seed = [...renumber(prefix, 0), ...renumber(seedSuffix, prefix.length)];
+		const internals = this.persistence.internals();
+		const sourceRows = await internals.backend.getEventRows(sourceId);
+		const sourceEventIds = new Map(sourceRows.map((row) => [row.fOriginalSeq, row.fEventId]));
+		const reuse = /* @__PURE__ */ new Map();
+		for (const event of prefix) {
+			const eventId = sourceEventIds.get(event.seq);
+			if (eventId !== void 0) reuse.set(event.seq, eventId);
+		}
+		internals.registerReuseEventIds(childId, reuse);
+		await this.persistence.create(childMeta, prefix.length);
+		if (seed.length > 0) await this.persistence.append(childId, seed);
+		return childId;
+	}
+	async rewind(id, toBoundary, signal) {
+		signal?.throwIfAborted();
+		if (!Number.isSafeInteger(toBoundary) || toBoundary < -1) throw new SessionBranchError(`rewind boundary must be a non-negative safe integer, got ${toBoundary}`, "INVALID_BOUNDARY");
+		const live = this.live.getSession(id);
+		if (live !== void 0) await this.live.flush(live);
+		const raw = live === void 0 ? await this.readRawEvents(id, signal) : void 0;
+		const inspection = live === void 0 ? void 0 : await this.persistence.inspect(id, signal);
+		const events = live === void 0 ? raw.events : inspection.events;
+		const meta = live === void 0 ? raw.meta : inspection.meta;
+		const boundaryEvent = events[toBoundary];
+		if (toBoundary === -1) {} else if (boundaryEvent === void 0) throw new SessionBranchError(`rewind boundary ${toBoundary} does not exist in session "${id}"`, "INVALID_BOUNDARY");
+		else if (boundaryEvent.type !== "turn/end" && boundaryEvent.type !== "user/message") throw new SessionBranchError(`rewind boundary ${toBoundary} is not a turn/end or user/message (${boundaryEvent.type})`, "INVALID_BOUNDARY");
+		const rawKeepLength = toBoundary === -1 ? 0 : boundaryEvent.type === "turn/end" ? toBoundary + 1 : toBoundary;
+		const keepLength = balanceRewindPrefix(events.slice(0, rawKeepLength)).length;
+		const internals = this.persistence.internals();
+		const denseBoundary = live === void 0 ? keepLength - 1 : events.slice(0, keepLength).filter(isPersistedEvent).length - 1;
+		const newSeedLength = await internals.backend.transaction(async (tx) => {
+			signal?.throwIfAborted();
+			const head = await tx.getHead(id);
+			if (denseBoundary > head.fHeadSequence) throw new SessionBranchError(`rewind boundary ${toBoundary} is beyond the stored head ${head.fHeadSequence}`, "INVALID_BOUNDARY");
+			if (denseBoundary < head.fHeadSequence) {
+				await tx.deleteBridgeTail(id, denseBoundary + 1);
+				const prev = denseBoundary === -1 ? void 0 : await tx.getPrevBridge(id, denseBoundary);
+				if (prev === void 0) await tx.updateHead(id, "", -1);
+				else await tx.updateHead(id, prev.fEventId, prev.fSequence);
+			}
+			const storedSeedLength = await tx.getSeedLength(id);
+			let shrunk = storedSeedLength;
+			if (storedSeedLength !== null && storedSeedLength > denseBoundary + 1) {
+				await tx.updateSeedLength(id, denseBoundary + 1);
+				shrunk = denseBoundary + 1;
+			}
+			await tx.bumpRevision(id);
+			return shrunk;
+		});
+		if (newSeedLength !== null) this.live.setCoordinatorSeedLength(id, newSeedLength);
+		internals.writeGuard.confirmHead(id, denseBoundary);
+		if (live !== void 0) {
+			truncateLiveSession(live, keepLength);
+			const agent = this.live.getAgent(id);
+			if (agent !== void 0) {
+				agent.requestHeaderLogged = false;
+				const lastTurn = live.snapshotEvents().findLast((e) => e.type === "turn/start")?.data.turn ?? 0;
+				const phase = agent.phase;
+				if (phase !== void 0) phase.lastTurn = lastTurn;
+			}
+			this.live.setCoordinatorCursor(id, keepLength);
+		} else if (boundaryEvent?.type === "user/message") this.live.setCoordinatorState(id, keepLength, meta);
+		else await this.persistence.load(id);
+		const row = await internals.backend.getSession(id);
+		if (row === void 0) return {
+			header: {
+				version: SESSION_FORMAT_VERSION,
+				id,
+				createdAt: meta.createdAt,
+				...meta.cwd !== void 0 ? { cwd: meta.cwd } : {},
+				...meta.parentSession !== void 0 ? { parentSession: meta.parentSession } : {},
+				isSeeded: meta.isSeeded,
+				...meta.origin !== void 0 ? { origin: meta.origin } : {},
+				...meta.delegationDepth !== void 0 ? { delegationDepth: meta.delegationDepth } : {},
+				...meta.agentPreset !== void 0 ? { agentPreset: meta.agentPreset } : {}
+			},
+			revision: await internals.readStoredRevision(id) ?? await this.persistence.readStoredRevision(id)
+		};
+		return {
+			header: rowToMeta(row),
+			revision: await internals.readStoredRevision(id)
+		};
+	}
+};
+var SessionBranchRdb = class extends SessionBranch {
+	static inject = ["sessionPersistence", "sessions"];
+	constructor(ctx) {
+		super(ctx);
+	}
+	provider = new SessionBranchRdbProvider(this.ctx.sessionPersistence, {
+		getSession: (id) => this.ctx.sessions.get(id),
+		getAgent: (id) => {
+			return this.ctx.get("agents")?.get(id);
+		},
+		flush: (session) => this.ctx.sessions.flush(session),
+		setCoordinatorCursor: (id, cursor) => {
+			const state = this.ctx.sessionPersistence.coordinator?.states?.get(id);
+			if (state !== void 0) state.cursor = cursor;
+		},
+		setCoordinatorState: (id, cursor, meta) => {
+			const states = this.ctx.sessionPersistence.coordinator?.states;
+			if (states === void 0) return;
+			const state = states.get(id);
+			if (state !== void 0) state.cursor = cursor;
+			else states.set(id, {
+				meta,
+				cursor,
+				materialized: true
+			});
+		},
+		setCoordinatorSeedLength: (id, seedLength) => {
+			const state = this.ctx.sessionPersistence.coordinator?.states?.get(id);
+			if (state?.storage !== void 0 && state.storage.inheritedEventCount > seedLength) state.storage = {
+				...state.storage,
+				inheritedEventCount: seedLength
+			};
+		}
+	});
+	readBranchPrefix(id, atSeq, mode, signal) {
+		return this.provider.readBranchPrefix(id, atSeq, mode, signal);
+	}
+	readRawEvents(id, signal) {
+		return this.provider.readRawEvents(id, signal);
+	}
+	forkFrom(sourceId, options, signal) {
+		return this.provider.forkFrom(sourceId, options, signal);
+	}
+	rewind(id, toBoundary, signal) {
+		return this.provider.rewind(id, toBoundary, signal);
+	}
+	syncLiveCursor(sessionId) {
+		const live = this.ctx.sessions.get(sessionId);
+		if (live === void 0) return;
+		const state = this.ctx.sessionPersistence.coordinator?.states?.get(sessionId);
+		if (state === void 0) return;
+		let cursor = state.cursor;
+		while (live.snapshotEvents()[cursor]?.ignorable === true) cursor += 1;
+		state.cursor = cursor;
+	}
+	async timeline(sessionId, signal) {
+		const persistence = this.ctx.sessionPersistence;
+		const snapshots = await persistence.listSnapshots(signal);
+		const readOwnEvents = async (id, fromSeq, s) => {
+			const live = this.ctx.sessions.get(id);
+			if (live !== void 0) return live.snapshotEvents().slice(fromSeq);
+			return (await persistence.readFrom(id, fromSeq, s)).events;
+		};
+		return buildTimeline(snapshots, readOwnEvents, sessionId, signal);
+	}
+};
+//#endregion
+//#region src/import.ts
+const SESSION_LOG_ARTIFACT_FILENAME = "session.jsonl";
+const SESSION_IMPORT_PATH = "/api/session.import";
+const MAX_IMPORT_ZIP_BYTES = 67108864;
+function expandProvenanceFromStorage(parsed) {
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError("imported session records must be objects");
+	const record = parsed;
+	if (record.sourceEventSeqs === void 0) return parsed;
+	if (!Number.isSafeInteger(record.seq) || record.seq < 0) throw new TypeError("imported session event seq must be a non-negative safe integer");
+	return {
+		...record,
+		sourceEventSeqs: decodeSeqRanges(record.sourceEventSeqs, record.seq + 1)
+	};
+}
+function parseJsonlArtifact(content) {
+	const lines = content.split("\n");
+	if (lines.length === 0 || lines[0] === "") throw new Error("imported session log is empty");
+	let header;
+	try {
+		header = JSON.parse(lines[0]);
+	} catch {
+		throw new Error("imported session log has an unparsable header line");
+	}
+	if (typeof header !== "object" || header === null || header["type"] !== "session" || typeof header["id"] !== "string" || typeof header["version"] !== "number" || !Number.isSafeInteger(header["createdAt"]) || header["createdAt"] < 0) throw new Error("imported session log has an invalid header line");
+	const seedLength = header["seedLength"];
+	if (seedLength !== void 0 && (!Number.isSafeInteger(seedLength) || seedLength < 0)) throw new Error("imported session log has an invalid seedLength");
+	const events = [];
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (line === void 0 || line === "") continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			throw new Error(`imported session log has an unparsable event line at ${i}`);
+		}
+		for (const event of decodeStorageRecord(expandProvenanceFromStorage(parsed))) events.push(event);
+	}
+	for (let i = 0; i < events.length; i++) if (events[i].seq !== i) throw new Error(`imported session log seq gap at ${i} (got ${events[i].seq}); import requires a dense log`);
+	const origin = header["origin"];
+	const delegationDepth = header["delegationDepth"];
+	const inheritedEventCount = Math.min(seedLength ?? 0, events.length);
+	return {
+		meta: {
+			version: header["version"],
+			id: header["id"],
+			createdAt: header["createdAt"],
+			...typeof header["cwd"] === "string" ? { cwd: header["cwd"] } : {},
+			...typeof header["parentSession"] === "string" ? { parentSession: header["parentSession"] } : {},
+			isSeeded: seedLength !== void 0,
+			...origin === "subagent" ? { origin } : {},
+			...Number.isSafeInteger(delegationDepth) && delegationDepth > 0 ? { delegationDepth } : {},
+			...typeof header["agentPreset"] === "string" ? { agentPreset: header["agentPreset"] } : {}
+		},
+		inheritedEventCount: SessionLogOffset(inheritedEventCount),
+		events
+	};
+}
+function parseImportZip(zip) {
+	let entries;
+	try {
+		entries = unzipSync(zip);
+	} catch {
+		throw new Error("imported zip is not a valid ZIP archive");
+	}
+	const artifact = entries[SESSION_LOG_ARTIFACT_FILENAME];
+	if (artifact === void 0) throw new Error(`imported zip is missing ${SESSION_LOG_ARTIFACT_FILENAME}`);
+	return parseJsonlArtifact(new TextDecoder().decode(artifact));
+}
+async function persistImport(persistence, branch, imported, targetId, sessions) {
+	const id = targetId ?? `session-${randomUUID()}`;
+	if (targetId !== void 0) {
+		if (branch === void 0) throw new Error("sessionBranch service is unavailable");
+		await branch.rewind(targetId, -1);
+	} else await persistence.create({
+		...imported.meta,
+		id
+	}, imported.inheritedEventCount);
+	if (imported.events.length > 0) await persistence.append(id, imported.events);
+	if (targetId !== void 0) {
+		const live = sessions?.get(targetId);
+		if (live !== void 0) replaceLiveSessionLog(live, imported.events);
+	}
+	return id;
+}
+function registerSessionImport(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_IMPORT_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const body = Buffer.concat(chunks);
+				let envelope;
+				try {
+					envelope = JSON.parse(body.toString("utf8"));
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				if (typeof envelope.zip !== "string" || envelope.zip === "") {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "missing zip field" }));
+					return;
+				}
+				if (envelope.sessionId !== void 0 && (typeof envelope.sessionId !== "string" || envelope.sessionId === "")) {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "sessionId must be a non-empty string" }));
+					return;
+				}
+				let zip;
+				try {
+					zip = Buffer.from(envelope.zip, "base64");
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "zip field is not valid base64" }));
+					return;
+				}
+				if (zip.byteLength > MAX_IMPORT_ZIP_BYTES) {
+					res.writeHead(413, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "imported zip exceeds the size limit" }));
+					return;
+				}
+				let imported;
+				try {
+					imported = parseImportZip(zip);
+				} catch (error) {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "imported zip is invalid" }));
+					return;
+				}
+				const targetId = typeof envelope.sessionId === "string" ? envelope.sessionId : void 0;
+				const branch = webCtx.get("sessionBranch");
+				try {
+					const sessions = webCtx.get("sessions");
+					const id = await persistImport(persistence, branch, imported, targetId, sessions);
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({ sessionId: id }));
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					if (targetId !== void 0 && /not found/i.test(message)) {
+						res.writeHead(404, { "content-type": "application/json" });
+						res.end(JSON.stringify({ error: `session "${targetId}" not found` }));
+						return;
+					}
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "import failed" }));
+					return;
+				}
+			}
+		}), `session-rdb: ${SESSION_IMPORT_PATH} route`);
+	});
+}
+//#endregion
+//#region src/index.ts
+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)
+	}), z.object({
+		type: z.const("postgres"),
+		connectionString: z.string().required(),
+		schema: z.string().default("public")
+	})]);
+	static settingsNs = "session-rdb";
+	name = "session-rdb";
+	supportsRawArtifacts = true;
+	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;
+		repairSurfaceOps(log.events);
+		recomputeReplaceProvenance(log.events);
+		const inheritedEventCount = Math.min(log.inheritedEventCount, log.events.length);
+		return {
+			meta: log.meta,
+			inheritedEventCount: SessionLogOffset(inheritedEventCount),
+			filename: "session.jsonl",
+			content: toJsonlArtifact(log.meta, inheritedEventCount, log.events)
+		};
+	}
+	backend;
+	storeIdentity;
+	ready;
+	coordinator;
+	writeGuard = new WriteGuard();
+	reuseEventIds = /* @__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.coordinator = new PersistenceCoordinator(this.ctx, this);
+		new SessionBranchRdb(this.ctx);
+		registerSessionImport(this.ctx, this);
+	}
+	async init() {
+		await this.backend.open();
+		this.storeIdentity = this.backend.storeIdentity;
+	}
+	locate(_meta) {}
+	create(meta, inheritedEventCount) {
+		return this.coordinator.create(meta, inheritedEventCount === void 0 ? void 0 : SessionLogOffset(inheritedEventCount));
+	}
+	append(id, events) {
+		return this.coordinator.append(id, events);
+	}
+	load(id) {
+		return this.coordinator.load(id);
+	}
+	inspect(id, signal) {
+		return this.coordinator.inspect(id, signal);
+	}
+	readFrom(id, fromSeq, signal) {
+		return this.coordinator.readFrom(id, fromSeq, signal);
+	}
+	borrowSession(id, signal) {
+		return this.coordinator.borrowSession(id, signal);
+	}
+	loadStored(id, signal) {
+		return this.readPrefix(id, signal);
+	}
+	async loadStoredFrom(id, fromSeq, signal) {
+		const log = await this.readLog(id, { fromSeq }, signal);
+		if (log === void 0) return void 0;
+		return {
+			meta: log.meta,
+			inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
+			events: log.events
+		};
+	}
+	async readPrefix(id, signal) {
+		const log = await this.readLog(id, {}, signal);
+		if (log === void 0) {
+			this.writeGuard.confirmHead(id, -1);
+			return;
+		}
+		this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
+		recomputeReplaceProvenance(log.events);
+		return {
+			meta: log.meta,
+			inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
+			events: log.events,
+			revision: SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${log.incarnation}:revision:${log.revision}`),
+			...log.tornFrom !== void 0 ? { tornMarker: log.tornFrom } : {}
+		};
+	}
+	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 SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`);
+	}
+	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);
+		let eventRows;
+		let seqMap;
+		if (options.fromSeq === void 0) {
+			eventRows = await this.backend.getEventRows(id);
+			seqMap = buildSeqMap(eventRows);
+		} else {
+			eventRows = await this.backend.getEventRows(id, options.fromSeq);
+			seqMap = buildSeqMap(await this.backend.getSeqMapRows(id));
+		}
+		signal?.throwIfAborted();
+		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0, seqMap);
+		return {
+			meta,
+			inheritedEventCount: row.fSeedLength ?? 0,
+			events: preserved,
+			incarnation: row.fIncarnation,
+			revision: row.fRevision,
+			...tornFrom !== void 0 ? { tornFrom } : {}
+		};
+	}
+	async appendBatch(storage, events, _isMaterialized) {
+		await this.ready;
+		const persisted = events.filter(isPersistedEvent);
+		if (persisted.length === 0) return;
+		const meta = storage.meta;
+		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) => {
+			await tx.upsertSession(storage, randomUUID());
+			const head = await tx.getHead(meta.id);
+			this.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
+			const { headEventId, headSequence } = await appendEventTail(tx, meta, persisted, {
+				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);
+	}
+	async commitRepair(storage, tornMarker, closers) {
+		await this.ready;
+		const meta = storage.meta;
+		const persistedClosers = closers.filter(isPersistedEvent);
+		if (tornMarker === void 0 && persistedClosers.length === 0) return;
+		await this.backend.transaction(async (tx) => {
+			if (tornMarker !== void 0) {
+				await tx.deleteBridgeTail(meta.id, tornMarker);
+				const prev = await tx.getPrevBridge(meta.id, tornMarker - 1);
+				if (prev === void 0) await tx.updateHead(meta.id, "", -1);
+				else await tx.updateHead(meta.id, prev.fEventId, prev.fSequence);
+			}
+			if (persistedClosers.length > 0) {
+				const last = await tx.getLastBridge(meta.id);
+				const { headEventId, headSequence } = await appendEventTail(tx, meta, persistedClosers, {
+					parentId: last?.fEventId ?? "",
+					nextSeq: (last?.fSequence ?? -1) + 1
+				});
+				await tx.updateHead(meta.id, headEventId, headSequence);
+			}
+			await tx.bumpRevision(meta.id);
+		});
+		const row = await this.backend.getSession(meta.id);
+		this.writeGuard.confirmHead(meta.id, row?.fHeadSequence ?? -1);
+	}
+	async list(signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const rows = await this.backend.listSessions();
+		signal?.throwIfAborted();
+		return rows.map(rowToMeta);
+	}
+	async listSnapshots(signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const rows = await this.backend.listSessions();
+		signal?.throwIfAborted();
+		return rows.map((row) => ({
+			header: rowToMeta(row),
+			revision: SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`),
+			inheritedEventCount: row.fSeedLength ?? 0
+		}));
+	}
+	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),
+			append: (id, events) => this.append(id, events),
+			load: (id) => this.load(id),
+			inspect: (id, signal) => this.inspect(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)
+		};
+	}
+};
+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);
+			eventRows.push({
+				fEventId: eventId,
+				fParentId: parentId,
+				fType: event.type,
+				fKind: kind,
+				fRole: role,
+				fName: name,
+				fActionId: actionId,
+				fEncoding: EVENT_ENCODING,
+				fData: JSON.stringify(event.data),
+				fCreatedAt: event.time
+			});
+		}
+		const surfaceOp = event.surfaceOp === void 0 ? null : JSON.stringify(event.surfaceOp);
+		bridgeRows.push({
+			fSessionId: meta.id,
+			fEventId: eventId,
+			fSequence: nextSeq,
+			fOriginalSeq: event.seq,
+			fSurfaceOp: surfaceOp
+		});
+		parentId = eventId;
+		nextSeq++;
+	}
+	if (eventRows.length > 0) await tx.insertEvents(eventRows);
+	await tx.insertBridges(bridgeRows);
+	return {
+		headEventId: parentId,
+		headSequence: nextSeq - 1
+	};
+}
+//#endregion
+export { EPHEMERAL_EVENT_TYPES, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, locateTurnEnd };
+
+//# sourceMappingURL=index.mjs.map