@morlay/session-rdb 0.0.15 → 0.0.16-alpha.1

package/dist/sqlite-CnWwGToZ.mjs

@@ -0,0 +1,698 @@
+import { d as sessionConflictRow, f as sessionInsertRow } from "./log-DBFUBPhv.mjs";
+import { randomUUID } from "node:crypto";
+import { and, 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 { readdirSync, statSync } from "node:fs";
+import { mkdir, open } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { drizzle } from "drizzle-orm/node-sqlite";
+import { migrate } from "drizzle-orm/node-sqlite/migrator";
+//#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/adapters/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(name, c, tables) {
+	let col;
+	switch (c.type) {
+		case "text": {
+			const built = text(name);
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+		case "serial":
+			col = integer(name).primaryKey({ autoIncrement: true });
+			break;
+		case "integer":
+		case "bigint": {
+			const built = integer(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 [name, c] of Object.entries(def.columns)) columns[toProperty(name)] = buildColumn$1(name, c, tables);
+		const extra = (self) => [
+			...Object.entries(def.checks ?? {}).map(([name, c]) => check(name, sql.raw(c.expression))),
+			...Object.entries(def.uniques ?? {}).map(([name, u]) => unique(name).on(...u.columns.map((n) => self[toProperty(n)]))),
+			...Object.entries(def.indexes ?? {}).map(([name, i]) => index(name).on(...i.columns.map((n) => self[toProperty(n)])))
+		];
+		tables[def.name] = sqliteTable(def.name, columns, extra);
+	}
+	return tables;
+}
+//#endregion
+//#region src/adapters/to-postgres.ts
+function buildColumn(name, c, tables) {
+	let col;
+	switch (c.type) {
+		case "text": {
+			const built = text$1(name);
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+		case "serial":
+			col = serial(name).primaryKey();
+			break;
+		case "integer": {
+			const built = integer$1(name);
+			col = c.primaryKey ? built.primaryKey() : built;
+			break;
+		}
+		case "bigint": {
+			const built = bigint(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 [name, c] of Object.entries(def.columns)) columns[toProperty(name)] = buildColumn(name, c, tables);
+		const extra = (self) => [
+			...Object.entries(def.checks ?? {}).map(([name, c]) => check$1(name, sql.raw(c.expression))),
+			...Object.entries(def.uniques ?? {}).map(([name, u]) => unique$1(name).on(...u.columns.map((n) => self[toProperty(n)]))),
+			...Object.entries(def.indexes ?? {}).map(([name, i]) => index$1(name).on(...i.columns.map((n) => self[toProperty(n)])))
+		];
+		tables[def.name] = table(def.name, columns, extra);
+	}
+	return tables;
+}
+//#endregion
+//#region src/entities/v3/persistence-state.ts
+const persistenceState = {
+	name: "t_persistence_state",
+	columns: {
+		f_singleton: {
+			type: "integer",
+			primaryKey: true
+		},
+		f_store_id: {
+			type: "text",
+			notNull: true
+		}
+	},
+	checks: { ck_persistence_state_singleton: { expression: "f_singleton = 1" } }
+};
+//#endregion
+//#region src/entities/v3/schema-meta.ts
+const schemaMeta = {
+	name: "t_schema_meta",
+	columns: {
+		f_key: {
+			type: "text",
+			primaryKey: true
+		},
+		f_value: {
+			type: "text",
+			notNull: true
+		}
+	}
+};
+//#endregion
+//#region src/entities/v3/sessions.ts
+const sessions = {
+	name: "t_sessions",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		f_head_event_id: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_head_sequence: {
+			type: "integer",
+			notNull: true,
+			default: -1
+		},
+		f_version: {
+			type: "integer",
+			notNull: true
+		},
+		f_created_at: {
+			type: "bigint",
+			notNull: true
+		},
+		f_cwd: { type: "text" },
+		f_parent_session: { type: "text" },
+		f_seed_length: { type: "integer" },
+		f_origin: { type: "text" },
+		f_delegation_depth: { type: "integer" },
+		f_incarnation: {
+			type: "text",
+			notNull: true
+		},
+		f_revision: {
+			type: "integer",
+			notNull: true
+		}
+	}
+};
+//#endregion
+//#region src/entities/v3/events.ts
+const events = {
+	name: "t_events",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_event_id: {
+			type: "text",
+			notNull: true,
+			unique: true
+		},
+		f_parent_id: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_type: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_kind: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_role: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_name: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_action_id: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_encoding: {
+			type: "text",
+			notNull: true,
+			default: ""
+		},
+		f_data: {
+			type: "text",
+			notNull: true
+		},
+		f_created_at: {
+			type: "bigint",
+			notNull: true,
+			default: 0
+		}
+	},
+	indexes: {
+		idx_events_kind: { columns: ["f_kind"] },
+		idx_events_role: { columns: ["f_role"] },
+		idx_events_name: { columns: ["f_name"] },
+		idx_events_action_id: { columns: ["f_action_id"] }
+	}
+};
+//#endregion
+//#region src/entities/v3/session-events.ts
+const sessionEvents$1 = {
+	name: "t_session_events",
+	columns: {
+		f_id: {
+			type: "serial",
+			primaryKey: true
+		},
+		f_session_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_sessions",
+				column: "f_session_id",
+				onDelete: "cascade"
+			}
+		},
+		f_event_id: {
+			type: "text",
+			notNull: true,
+			references: {
+				table: "t_events",
+				column: "f_event_id",
+				onDelete: "cascade"
+			}
+		},
+		f_sequence: {
+			type: "integer",
+			notNull: true
+		},
+		f_surface_op: { type: "text" }
+	},
+	uniques: { uq_session_events_session_sequence: { columns: ["f_session_id", "f_sequence"] } },
+	indexes: { idx_session_events_event_id: { columns: ["f_event_id"] } }
+};
+//#endregion
+//#region src/entities/v3/index.ts
+const sqliteTableDefs = [
+	persistenceState,
+	schemaMeta,
+	sessions,
+	events,
+	sessionEvents$1
+];
+const postgresTableDefs = [
+	persistenceState,
+	schemaMeta,
+	sessions,
+	events,
+	sessionEvents$1
+];
+({ ...sessionEvents$1 }), { ...sessionEvents$1.columns };
+//#endregion
+//#region src/schema.ts
+const SCHEMA_VERSION = 3;
+const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+const EVENT_ENCODING = "json";
+const sqliteTables = toSqliteSchema(sqliteTableDefs);
+const tPersistenceState = sqliteTables["t_persistence_state"];
+const tSchemaMeta = sqliteTables["t_schema_meta"];
+const tSessions = sqliteTables["t_sessions"];
+const tEvents = sqliteTables["t_events"];
+const tSessionEvents = sqliteTables["t_session_events"];
+const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+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: ""
+		};
+	}
+}
+//#endregion
+//#region src/sqlite.ts
+/** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
+const sqliteMigrationsDir = new URL("../drizzle/sqlite/", import.meta.url).pathname;
+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);
+		const dbx = drizzle({ client: db });
+		const { user_version: onDisk } = db.prepare("PRAGMA user_version").get();
+		if (onDisk === 2 && !hasMigrationsTable(db)) baselineV2(db);
+		migrate(dbx, { migrationsFolder: sqliteMigrationsDir });
+		dbx.insert(tPersistenceState).values({
+			fSingleton: 1,
+			fStoreId: randomUUID()
+		}).onConflictDoNothing().run();
+		if (onDisk === 0 || onDisk === 2) db.exec(`PRAGMA user_version = 3`);
+		db.exec(`PRAGMA journal_mode = ${journalMode.toUpperCase()}`);
+		return db;
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+}
+function hasMigrationsTable(db) {
+	return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = '__drizzle_migrations'").get() !== void 0;
+}
+/** 标记 v2 baseline 已应用（迁移表 v1 结构：id/hash/created_at/name/applied_at）。 */
+function baselineV2(db) {
+	const dir = readdirSync(sqliteMigrationsDir).find((name) => name.endsWith("_v2_initial"));
+	if (dir === void 0) throw new Error("missing v2 baseline migration in drizzle/sqlite");
+	db.exec(`
+    CREATE TABLE __drizzle_migrations (
+      id INTEGER PRIMARY KEY,
+      hash text NOT NULL,
+      created_at numeric,
+      name text,
+      applied_at TEXT
+    )
+  `);
+	db.prepare("INSERT INTO __drizzle_migrations (hash, created_at, name, applied_at) VALUES (?, ?, ?, ?)").run("baseline", 0, dir, (/* @__PURE__ */ new Date()).toISOString());
+}
+function configureDatabase(db, path, journalMode, busyTimeout) {
+	db.exec("PRAGMA foreign_keys = ON");
+	db.exec(`PRAGMA busy_timeout = ${busyTimeout}`);
+	drizzle({ 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 !== 0 && onDisk !== 2 && onDisk !== 3) throw new Error(`session database at "${path}" has schema version ${onDisk}, incompatible with this build (3)`);
+		if (onDisk >= 1 && applicationId !== 1146308688) throw new Error(`session database at "${path}" has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
+		if (onDisk === 0) {
+			tx.run(sql.raw(`PRAGMA application_id = ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`));
+			tx.run(sql.raw(`PRAGMA user_version = 3`));
+		}
+	}, { behavior: "immediate" });
+}
+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({ client: openDatabase(actual, this.options.journalMode, this.options.busyTimeout) });
+			migrate(this.db, { migrationsFolder: sqliteMigrationsDir });
+		});
+		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 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)
+	};
+	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();
+	}
+	eventRows() {
+		return this.db.select({
+			fEventId: tSessionEvents.fEventId,
+			fSequence: tSessionEvents.fSequence,
+			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
+export { SCHEMA_VERSION as a, eventKind as c, tSchemaMeta as d, tSessionEvents as f, WriteGuard as g, toPostgresSchema as h, EVENT_ENCODING as i, tEvents as l, postgresTableDefs as m, openDatabase as n, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as o, tSessions as p, DEFAULT_BUSY_TIMEOUT_MS as r, eventDimensions as s, SqliteBackend as t, tPersistenceState as u };