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

package/dist/sqlite-CG_Qcx5C.mjs

@@ -1,356 +0,0 @@
-import { A as sessionInsertRow, a as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, d as tPersistenceState, f as tSessionEvents, h as sqliteTableDefs, k as sessionConflictRow, o as eventDimensions, p as tSessions, t as DEFAULT_BUSY_TIMEOUT_MS, u as tEvents } from "./schema-vwzwEXNE.mjs";
-import { randomUUID } from "node:crypto";
-import { and, desc, eq, gte, sql } from "drizzle-orm";
-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 } from "drizzle-orm/node-sqlite";
-//#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/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;
-}
-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({ 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({ 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
-export { WriteGuard as i, openDatabase as n, createTablesSql as r, SqliteBackend as t };

package/src/adapters/ddl.ts

@@ -1,77 +0,0 @@
-import type { ColumnDef, TableDef } from "../entities/types.ts";
-
-export type Dialect = "sqlite" | "postgres";
-
-function sqlType(dialect: Dialect, type: ColumnDef["type"]): string {
-  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: string | number): string {
-  return typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : String(value);
-}
-
-function quote(name: string): string {
-  return `"${name}"`;
-}
-
-function columnSql(dialect: Dialect, c: ColumnDef): string {
-  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 !== undefined) 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;
-}
-
-export function createTableSql(dialect: Dialect, def: TableDef, schema?: string): string {
-  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" : "";
-  const qualified =
-    schema === undefined || schema === "public"
-      ? quote(def.name)
-      : `${quote(schema)}.${quote(def.name)}`;
-  return `CREATE TABLE IF NOT EXISTS ${qualified} (\n  ${parts.join(",\n  ")}\n)${strict}`;
-}
-
-export function createIndexSql(def: TableDef, name: string, schema?: string): string {
-  const idx = def.indexes?.find((i) => i.name === name);
-  if (idx === undefined) throw new Error(`unknown index "${name}" on table "${def.name}"`);
-  const qualified =
-    schema === undefined || 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(", ")})`;
-}
-
-export function createTablesSql(
-  dialect: Dialect,
-  defs: readonly TableDef[],
-  schema?: string,
-): string[] {
-  const statements: string[] = [];
-  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;
-}

package/src/entities/events.ts

@@ -1,27 +0,0 @@
-import type { TableDef } from "./types.ts";
-
-export const events: TableDef = {
-  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 },
-  ],
-  // 查询经 f_event_id（列级 UNIQUE 唯一索引）与 t_session_events 复合索引
-  // （按 session 过滤后回表）；f_parent_id 仅写路径构造；维度列索引为
-  // 审计/UI 过滤预留。
-  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"] },
-  ],
-};

package/src/entities/persistence-state.ts

@@ -1,10 +0,0 @@
-import type { TableDef } from "./types.ts";
-
-export const persistenceState: TableDef = {
-  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" }],
-};

package/src/entities/schema-meta.ts

@@ -1,9 +0,0 @@
-import type { TableDef } from "./types.ts";
-
-export const schemaMeta: TableDef = {
-  name: "t_schema_meta",
-  columns: [
-    { name: "f_key", type: "text", primaryKey: true },
-    { name: "f_value", type: "text", notNull: true },
-  ],
-};

package/src/entities/session-events.ts

@@ -1,29 +0,0 @@
-import type { TableDef } from "./types.ts";
-
-export const sessionEvents: TableDef = {
-  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"] },
-  ],
-  // UNIQUE(f_session_id, f_sequence) 自动建唯一索引（按 session 过滤 + seq
-  // 范围/排序/取尾）；f_event_id 索引覆盖反向查找（孤儿事件行清理）。
-  indexes: [{ name: "idx_session_events_event_id", columns: ["f_event_id"] }],
-};

package/src/entities/sessions.ts

@@ -1,20 +0,0 @@
-import type { TableDef } from "./types.ts";
-
-export const sessions: TableDef = {
-  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 },
-  ],
-};

package/src/migrate.ts

@@ -1,137 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { eventDimensions } from "./schema.ts";
-
-export const SCHEMA_VERSION_V2 = 2;
-
-export function migrateSqliteV1ToV2(db: DatabaseSync): number {
-  const { user_version: onDisk } = db.prepare("PRAGMA user_version").get() as {
-    user_version: number;
-  };
-  if (onDisk === SCHEMA_VERSION_V2) return 0;
-  if (onDisk !== 1) {
-    throw new Error(`unsupported schema version ${onDisk} (expected 1)`);
-  }
-
-  // 1. 建 v2 表（临时名）。
-  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);
-  `);
-
-  // 2. 搬运 t_events：f_type = 旧 f_kind，维度列重算。
-  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() as Array<{
-    f_event_id: string;
-    f_parent_id: string;
-    f_kind: string;
-    f_data: string;
-    f_created_at: number;
-  }>;
-  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: unknown;
-    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,
-    } as never);
-    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,
-    );
-  }
-
-  // 3. 搬运 t_session_events：f_original_seq / f_surface_op 从旧 t_events 取。
-  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() as Array<{ f_session_id: string; f_event_id: string; f_sequence: number }>;
-  const oldEventMeta = new Map(
-    (
-      db.prepare(`SELECT f_event_id, f_original_seq, f_surface_op FROM t_events`).all() as Array<{
-        f_event_id: string;
-        f_original_seq: number;
-        f_surface_op: string | null;
-      }>
-    ).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 === undefined) {
-      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,
-    );
-  }
-
-  // 4. 删旧表、重命名新表。
-  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;
-  `);
-
-  // 5. user_version = 2。
-  db.exec(`PRAGMA user_version = ${SCHEMA_VERSION_V2}`);
-  return oldEvents.length;
-}