@morlay/session-rdb 0.0.12 → 0.0.14

package/dist/index.mjs

@@ -1,1145 +1,13 @@
+import { i as WriteGuard, r as createTablesSql, t as SqliteBackend } from "./sqlite-BUWnS0so.mjs";
+import { A as sessionInsertRow, D as rowToMeta, O as scanRows, T as repairSurfaceOps, _ as buildSeqMap, a as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, b as recomputeReplaceProvenance, g as toPostgresSchema, i as SCHEMA_VERSION, j as toJsonlArtifact, k as sessionConflictRow, l as isPersistedEvent, m as postgresTableDefs, n as EPHEMERAL_EVENT_TYPES, o as eventDimensions, r as EVENT_ENCODING, t as DEFAULT_BUSY_TIMEOUT_MS, w as repairOrphanInboxSplices } from "./schema-BfPVmr1X.mjs";
+import { c as SessionBranchRdb, l as SessionBranchRdbProvider, s as registerSessionImport, u as locateTurnEnd } from "./import-B-tf5vQn.mjs";
 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 { SessionLogOffset } 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;
@@ -1293,438 +161,6 @@ var PostgresBackend = class PostgresBackend {
 	}
 };
 //#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;
@@ -1831,6 +267,7 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 		}
 		this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
 		recomputeReplaceProvenance(log.events);
+		repairOrphanInboxSplices(log.events);
 		return {
 			meta: log.meta,
 			inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
@@ -1861,7 +298,8 @@ var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersisten
 			seqMap = buildSeqMap(eventRows);
 		} else {
 			eventRows = await this.backend.getEventRows(id, options.fromSeq);
-			seqMap = buildSeqMap(await this.backend.getSeqMapRows(id));
+			const seqRows = await this.backend.getSeqMapRows(id);
+			seqMap = buildSeqMap(seqRows);
 		}
 		signal?.throwIfAborted();
 		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0, seqMap);
@@ -2026,5 +464,3 @@ async function appendEventTail(tx, meta, events, anchor, reuse) {
 }
 //#endregion
 export { EPHEMERAL_EVENT_TYPES, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, locateTurnEnd };
-
-//# sourceMappingURL=index.mjs.map