@morlay/session-rdb 0.0.11 → 0.0.13

package/dist/schema-CFXZURX7.d.mts

@@ -0,0 +1,116 @@
+import { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+import { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+//#region src/backend.d.ts
+interface SessionRow {
+  fSessionId: string;
+  fHeadEventId: string;
+  fHeadSequence: number;
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+  fIncarnation: string;
+  fRevision: number;
+}
+interface EventInsert {
+  fEventId: string;
+  fParentId: string;
+  fType: string;
+  fKind: string;
+  fRole: string;
+  fName: string;
+  fActionId: string;
+  fEncoding: string;
+  fData: string;
+  fCreatedAt: number;
+}
+interface EventRow {
+  fEventId: string;
+  fSequence: number;
+  fOriginalSeq: number;
+  fType: string;
+  fKind: string;
+  fRole: string;
+  fName: string;
+  fActionId: string;
+  fCreatedAt: number;
+  fData: string;
+  fSurfaceOp: string | null;
+}
+interface BackendTx {
+  upsertSession(storage: SessionStorageMetadata, incarnation: string): Promise<void>;
+  getHead(id: SessionId): Promise<Pick<SessionRow, "fHeadEventId" | "fHeadSequence">>;
+  getSeedLength(id: SessionId): Promise<number | null>;
+  updateSeedLength(id: SessionId, seedLength: number): Promise<void>;
+  insertEvents(events: EventInsert[]): Promise<void>;
+  insertBridges(rows: Array<{
+    fSessionId: SessionId;
+    fEventId: string;
+    fSequence: number;
+    fOriginalSeq: number;
+    fSurfaceOp: string | null;
+  }>): Promise<void>;
+  updateHead(id: SessionId, headEventId: string, headSequence: number): Promise<void>;
+  bumpRevision(id: SessionId): Promise<void>;
+  deleteBridgeTail(id: SessionId, fromSequence: number): Promise<void>;
+  getPrevBridge(id: SessionId, sequence: number): Promise<{
+    fEventId: string;
+    fSequence: number;
+  } | undefined>;
+  getLastBridge(id: SessionId): Promise<{
+    fEventId: string;
+    fSequence: number;
+  } | undefined>;
+}
+interface Backend {
+  readonly kind: "sqlite" | "postgres";
+  readonly storeIdentity: string;
+  open(): Promise<void>;
+  getSession(id: SessionId): Promise<SessionRow | undefined>;
+  getSeqMapRows(id: SessionId): Promise<Array<{
+    fSequence: number;
+    fOriginalSeq: number;
+  }>>;
+  getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
+  listSessions(): Promise<SessionRow[]>;
+  transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/write-guard.d.ts
+declare class WriteGuard {
+  private readonly headSeqs;
+  confirmHead(id: SessionId, head: number): void;
+  assertNoConcurrentWriter(id: SessionId, storedHead: number): void;
+}
+//#endregion
+//#region src/schema.d.ts
+declare const SCHEMA_VERSION = 2;
+declare const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+declare const EPHEMERAL_EVENT_TYPES: readonly ["assistant/chunk"];
+declare const EVENT_ENCODING = "json";
+declare const tPersistenceState: any;
+declare const tSessions: any;
+declare const tEvents: any;
+declare const tSessionEvents: any;
+type JournalMode = "wal" | "delete" | "truncate" | "persist";
+declare const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+declare function isEphemeralType(type: string): boolean;
+declare function isPersistedEvent(event: SessionEvent): boolean;
+type EventKind = "message" | "thinking" | "turn" | "tool" | "request" | "config" | "audit" | "lifecycle" | "inbox" | "compaction" | "llm" | "subagent" | "team" | "workflow" | "goal" | "schedule" | "todo" | "web";
+type EventRole = "user" | "assistant" | "tool";
+declare function eventKind(event: {
+  type: string;
+  data?: unknown;
+}): EventKind | "";
+declare function eventDimensions(event: SessionEvent): {
+  kind: string;
+  role: string;
+  name: string;
+  actionId: string;
+};
+//#endregion
+export { WriteGuard as _, EventRole as a, EventRow as b, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as c, isEphemeralType as d, isPersistedEvent as f, tSessions as g, tSessionEvents as h, EventKind as i, eventDimensions as l, tPersistenceState as m, EPHEMERAL_EVENT_TYPES as n, JournalMode as o, tEvents as p, EVENT_ENCODING as r, SCHEMA_VERSION as s, DEFAULT_BUSY_TIMEOUT_MS as t, eventKind as u, Backend as v, SessionRow as x, BackendTx as y };

package/dist/sqlite-DIXY-dFZ.mjs

@@ -0,0 +1,356 @@
+import { O as sessionConflictRow, a as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, d as tPersistenceState, f as tSessionEvents, h as sqliteTableDefs, k as sessionInsertRow, o as eventDimensions, p as tSessions, t as DEFAULT_BUSY_TIMEOUT_MS, u as tEvents } from "./schema-B-8G4lWc.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/dist/storage.d.mts

@@ -0,0 +1,44 @@
+import { _ as WriteGuard, a as EventRole, b as EventRow, c as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, d as isEphemeralType, f as isPersistedEvent, g as tSessions, h as tSessionEvents, i as EventKind, l as eventDimensions, m as tPersistenceState, n as EPHEMERAL_EVENT_TYPES, o as JournalMode, p as tEvents, r as EVENT_ENCODING, s as SCHEMA_VERSION, t as DEFAULT_BUSY_TIMEOUT_MS, u as eventKind, v as Backend, x as SessionRow, y as BackendTx } from "./schema-CFXZURX7.mjs";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { DatabaseSync } from "node:sqlite";
+//#region src/sqlite.d.ts
+declare function openDatabase(path: string, journalMode: JournalMode, busyTimeout?: number): DatabaseSync;
+interface SqliteBackendOptions {
+  path: string;
+  journalMode: JournalMode;
+  busyTimeout: number;
+}
+declare class SqliteBackend implements Backend {
+  private readonly options;
+  readonly kind: "sqlite";
+  storeIdentity: string;
+  private dbPath;
+  private db;
+  constructor(options: SqliteBackendOptions);
+  open(): Promise<void>;
+  close(): Promise<void>;
+  getSession(id: SessionId): Promise<SessionRow | undefined>;
+  getSeqMapRows(id: SessionId): Promise<Array<{
+    fSequence: number;
+    fOriginalSeq: number;
+  }>>;
+  getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
+  listSessions(): Promise<SessionRow[]>;
+  transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
+  private readonly tx;
+  private upsertSession;
+  private getHead;
+  private getSeedLength;
+  private updateSeedLength;
+  private static readonly INSERT_BATCH_ROWS;
+  private insertEvents;
+  private insertBridges;
+  private updateHead;
+  private bumpRevision;
+  private deleteBridgeTail;
+  private getPrevBridge;
+  private getLastBridge;
+  private eventRows;
+}
+//#endregion
+export { DEFAULT_BUSY_TIMEOUT_MS, EPHEMERAL_EVENT_TYPES, EVENT_ENCODING, EventKind, EventRole, type EventRow, JournalMode, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, type SessionRow, SqliteBackend, SqliteBackendOptions, WriteGuard, eventDimensions, eventKind, isEphemeralType, isPersistedEvent, openDatabase, tEvents, tPersistenceState, tSessionEvents, tSessions };

package/dist/storage.mjs

@@ -0,0 +1,3 @@
+import { i as WriteGuard, n as openDatabase, t as SqliteBackend } from "./sqlite-DIXY-dFZ.mjs";
+import { a as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, c as isEphemeralType, d as tPersistenceState, f as tSessionEvents, i as SCHEMA_VERSION, l as isPersistedEvent, n as EPHEMERAL_EVENT_TYPES, o as eventDimensions, p as tSessions, r as EVENT_ENCODING, s as eventKind, t as DEFAULT_BUSY_TIMEOUT_MS, u as tEvents } from "./schema-B-8G4lWc.mjs";
+export { DEFAULT_BUSY_TIMEOUT_MS, EPHEMERAL_EVENT_TYPES, EVENT_ENCODING, SCHEMA_VERSION, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, SqliteBackend, WriteGuard, eventDimensions, eventKind, isEphemeralType, isPersistedEvent, openDatabase, tEvents, tPersistenceState, tSessionEvents, tSessions };

package/dist/testing.d.mts

@@ -0,0 +1,31 @@
+import { SessionPersistence } from "@deepseek-ai/dsh-session-persistence";
+import { Session, SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
+import { SettingsNamespace, SettingsProvider } from "@deepseek-ai/dsh-settings";
+import { Context, Fiber } from "@deepseek-ai/cordis";
+//#region src/testing/helpers.d.ts
+declare class EmptySettings extends SettingsProvider {
+  constructor(ctx: Context);
+  get writable(): boolean;
+  protected load(): Promise<Record<string, unknown>>;
+  protected persist(_ns: SettingsNamespace, _section: Record<string, unknown>): Promise<void>;
+}
+//#endregion
+//#region src/testing/contract.d.ts
+interface ContractBackend {
+  persistence: SessionPersistence;
+  dispose: () => Promise<void>;
+}
+declare function meta(id: string, cwd?: string): SessionHeader;
+declare function oneTurnLog(): SessionEvent[];
+declare function appendLog(session: Session, events: readonly SessionEvent[]): void;
+declare function runPersistenceContract(name: string, make: () => Promise<ContractBackend>): void;
+//#endregion
+//#region src/testing/coordinator-contract.d.ts
+interface CoordinatorFixture {
+  mount: (ctx: Context) => Promise<Fiber>;
+  corruptTail?: (id: SessionId, cwd: string | undefined) => Promise<void>;
+  cleanup: () => Promise<void>;
+}
+declare function runCoordinatorContract(name: string, makeFixture: () => Promise<CoordinatorFixture>): void;
+//#endregion
+export { type ContractBackend, type CoordinatorFixture, EmptySettings, appendLog, meta, oneTurnLog, runCoordinatorContract, runPersistenceContract };