@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/session-persistence-sqlite/lib/index.js

@@ -1,487 +1,1217 @@
+import { Service } from "../../cordis/lib/index.js";
 import z from "../../schemastery/lib/index.mjs";
-import { randomUUID } from "node:crypto";
-import { statSync } from "node:fs";
-import { mkdir, open } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
 import { DEFAULT_PREPARED_SESSION_CACHE_SIZE, DEFAULT_WRITE_BATCH_MAX_DELAY_MS, MAX_WRITE_BATCH_DELAY_MS, PersistenceCoordinator, SessionPersistence, SessionPersistenceRevision } from "../../session-persistence/lib/index.js";
-import { DatabaseSync } from "node:sqlite";
-//#region lib/types/schema.js
-/**
-* Schema + load-time helpers for the SQLite session-persistence backend: the
-* DDL (a store-identity row, `sessions` metadata, and a 1:1 `events` row per
-* `SessionEvent`), the database open/configure step, and the last-`turn/end`
-* cut that gives the SQLite backend the SAME crash-tail-on-load semantics as
-* the JSONL backend.
-*
-* @module nomix-session-persistence-sqlite/schema
-*/
-/**
-* The on-disk schema version. Bumped only on a breaking change to the table
-* layout; orthogonal to a session's own `version` (which versions the EVENT
-* vocabulary, stored per session in the `sessions` row).
-*/
-const SCHEMA_VERSION = 15;
-/** SQLite application id protecting unrelated databases from persistence writes. */
-const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+import { randomUUID } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { TextDecoder } from "node:util";
+import { constants, zstdCompressSync, zstdDecompressSync } from "node:zlib";
+import { performance } from "node:perf_hooks";
+import { setTimeout } from "node:timers/promises";
+import { SessionId } from "../../session/lib/index.js";
+import { fileURLToPath } from "node:url";
+/** Maximum logical members represented by one packed physical record. */
+const MAX_PACKED_ROW_MEMBERS = 1024;
+/** Maximum UTF-8 bytes in one packed physical record's data column. */
+const MAX_PACKED_DATA_BYTES = 1048576;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function hasExactKeys(value, keys) {
+	return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function classify(event) {
+	if (event.type !== "assistant/chunk") return void 0;
+	if (!hasExactKeys(event, [
+		"type",
+		"seq",
+		"time",
+		"data"
+	])) return void 0;
+	if (!Number.isSafeInteger(event.seq) || event.seq < 0 || !Number.isSafeInteger(event.time)) return void 0;
+	const data = event.data;
+	if (!isRecord(data) || !hasExactKeys(data, [
+		"turn",
+		"step",
+		"chunk"
+	])) return void 0;
+	if (typeof data.turn !== "number" || typeof data.step !== "number") return void 0;
+	const chunk = data.chunk;
+	if (!isRecord(chunk) || typeof chunk.index !== "number") return void 0;
+	switch (chunk.type) {
+		case "text-delta":
+		case "reasoning-delta": return hasExactKeys(chunk, [
+			"type",
+			"index",
+			"text"
+		]) && typeof chunk.text === "string" ? chunk.type : void 0;
+		case "tool-call-delta": return (hasExactKeys(chunk, [
+			"type",
+			"index",
+			"id",
+			"argumentsDelta"
+		]) || hasExactKeys(chunk, [
+			"type",
+			"index",
+			"id",
+			"name",
+			"argumentsDelta"
+		]) && typeof chunk.name === "string") && typeof chunk.id === "string" && typeof chunk.argumentsDelta === "string" ? chunk.type : void 0;
+		default: return;
+	}
+}
+function toolCallOf(event) {
+	return event.data.chunk;
+}
+function indexOf(event) {
+	return event.data.chunk.index;
+}
+function continues(previous, next, kind) {
+	if (next.seq !== previous.seq + 1 || !Number.isSafeInteger(next.time - previous.time)) return false;
+	if (next.data.turn !== previous.data.turn || next.data.step !== previous.data.step) return false;
+	if (indexOf(next) !== indexOf(previous)) return false;
+	if (kind !== "tool-call-delta") return true;
+	const left = toolCallOf(previous);
+	const right = toolCallOf(next);
+	return left.id === right.id && Object.hasOwn(left, "name") === Object.hasOwn(right, "name") && left.name === right.name;
+}
+function buildRow(kind, run) {
+	const first = run[0];
+	const base = {
+		turn: first.data.turn,
+		step: first.data.step,
+		index: indexOf(first),
+		dt: run.slice(1).map((event, index) => event.time - run[index].time)
+	};
+	const envelope = {
+		seq0: first.seq,
+		time0: first.time
+	};
+	if (kind === "tool-call-delta") {
+		const call = toolCallOf(first);
+		return {
+			type: "tool-call-chunks",
+			...envelope,
+			data: {
+				...base,
+				id: call.id,
+				...Object.hasOwn(call, "name") ? { name: call.name } : {},
+				args: run.map((event) => event.data.chunk.argumentsDelta)
+			}
+		};
+	}
+	const data = {
+		...base,
+		texts: run.map((event) => event.data.chunk.text)
+	};
+	return kind === "text-delta" ? {
+		type: "text-chunks",
+		...envelope,
+		data
+	} : {
+		type: "reasoning-chunks",
+		...envelope,
+		data
+	};
+}
+function packedDataBytes(row) {
+	return Buffer.byteLength(JSON.stringify(row.data));
+}
+function emitBoundedRun(out, kind, completeRun) {
+	let offset = 0;
+	while (completeRun.length - offset >= 3) {
+		let low = 3;
+		let high = Math.min(completeRun.length - offset, MAX_PACKED_ROW_MEMBERS);
+		const largest = buildRow(kind, completeRun.slice(offset, offset + high));
+		if (packedDataBytes(largest) <= 1048576) {
+			out.push(largest);
+			offset += high;
+			continue;
+		}
+		high -= 1;
+		let accepted = 0;
+		let acceptedRow;
+		while (low <= high) {
+			const middle = Math.floor((low + high) / 2);
+			const candidate = buildRow(kind, completeRun.slice(offset, offset + middle));
+			if (packedDataBytes(candidate) <= 1048576) {
+				accepted = middle;
+				acceptedRow = candidate;
+				low = middle + 1;
+			} else high = middle - 1;
+		}
+		if (accepted === 0) {
+			out.push(completeRun[offset]);
+			offset += 1;
+			continue;
+		}
+		/* v8 ignore next -- accepted is set only with its same-branch candidate. */
+		out.push(acceptedRow ?? malformed(kind, "bounded encoder lost its accepted row"));
+		offset += accepted;
+	}
+	out.push(...completeRun.slice(offset));
+}
 /**
-* Open the database and apply its schema and pragmas. An empty database with a
-* zero `user_version` is initialized at {@link SCHEMA_VERSION}; a nonempty
-* unversioned database and every other non-current version reject rather than
-* being migrated in place.
-* @param path - the SQLite database file to open (created when absent).
-* @param journalMode - validated journal pragma.
-* @returns the open handle with pragmas applied and all three tables ensured.
+* Pack eligible logical chunk runs into bounded schema-17 records.
+* @param events - logical events in sequence order.
+* @returns scalar and packed physical records in equivalent order.
 */
-function openDatabase(path, journalMode) {
-	const db = new DatabaseSync(path);
-	try {
-		configureDatabase(db, path, journalMode);
-		return db;
-	} catch (error) {
-		db.close();
-		throw error;
+function packChunkRuns(events) {
+	const out = [];
+	let kind;
+	let run = [];
+	const flush = () => {
+		if (kind === void 0) out.push(...run);
+		else emitBoundedRun(out, kind, run);
+		kind = void 0;
+		run = [];
+	};
+	for (const event of events) {
+		const nextKind = classify(event);
+		if (nextKind === void 0) {
+			flush();
+			out.push(event);
+			continue;
+		}
+		const delta = event;
+		const previous = run.at(-1);
+		if (nextKind === kind && previous !== void 0 && continues(previous, delta, nextKind)) {
+			run.push(delta);
+			continue;
+		}
+		flush();
+		kind = nextKind;
+		run = [delta];
 	}
+	flush();
+	return out;
 }
-function configureDatabase(db, path, journalMode) {
-	db.exec("PRAGMA foreign_keys = ON");
-	let began = false;
-	try {
-		db.exec("BEGIN IMMEDIATE");
-		began = true;
-		const { user_version: onDisk } = db.prepare("PRAGMA user_version").get();
-		const { application_id: applicationId } = db.prepare("PRAGMA application_id").get();
-		const { count: userObjectCount } = db.prepare("SELECT COUNT(*) AS count FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*'").get();
-		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 !== 15) throw new Error(`session database at "${path}" has schema version ${onDisk}, incompatible with this build (15)`);
-		if (onDisk === 15 && applicationId !== 1146308688) throw new Error(`session database at "${path}" has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
-		db.exec(`
-      CREATE TABLE IF NOT EXISTS persistence_state (
-        singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-        store_id  TEXT NOT NULL
-      ) STRICT;
-
-      CREATE TABLE IF NOT EXISTS sessions (
-        id               TEXT PRIMARY KEY,
-        version          INTEGER NOT NULL,
-        created_at       INTEGER NOT NULL,
-        cwd              TEXT,
-        parent_session   TEXT,
-        seed_length      INTEGER,
-        origin           TEXT,
-        delegation_depth INTEGER,
-        agent_preset    TEXT,
-        incarnation      TEXT NOT NULL,
-        revision         INTEGER NOT NULL
-      ) STRICT;
-
-      CREATE TABLE IF NOT EXISTS events (
-        session_id        TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-        seq               INTEGER NOT NULL,
-        type              TEXT NOT NULL,
-        time              INTEGER NOT NULL,
-        data              TEXT NOT NULL,
-        source_event_seqs TEXT,
-        surface_op        TEXT,
-        ignorable         INTEGER,
-        PRIMARY KEY (session_id, seq)
-      ) STRICT
-    `);
-		db.prepare("INSERT OR IGNORE INTO persistence_state (singleton, store_id) VALUES (1, ?)").run(randomUUID());
-		if (onDisk === 0) {
-			db.exec(`PRAGMA application_id = ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
-			db.exec(`PRAGMA user_version = 15`);
+function malformed(tag, reason) {
+	throw new Error(`malformed ${tag} storage row: ${reason}`);
+}
+function validateRunData(tag, data, payloadKey, serializedBytes) {
+	if (typeof data.turn !== "number" || typeof data.step !== "number" || typeof data.index !== "number") malformed(tag, "turn/step/index must be numbers");
+	const payload = data[payloadKey];
+	if (!Array.isArray(payload) || payload.length < 3 || payload.length > 1024 || payload.some((member) => typeof member !== "string")) malformed(tag, `${payloadKey} must contain 3..${MAX_PACKED_ROW_MEMBERS} strings`);
+	const gaps = data.dt;
+	if (!Array.isArray(gaps) || gaps.some((gap) => !Number.isSafeInteger(gap))) malformed(tag, "dt must be an array of safe integers");
+	if (gaps.length !== payload.length - 1) malformed(tag, "dt length must match the member count");
+	if ((serializedBytes ?? Buffer.byteLength(JSON.stringify(data))) > 1048576) malformed(tag, `data exceeds ${MAX_PACKED_DATA_BYTES} UTF-8 bytes`);
+	return payload;
+}
+function validateRow(value, tag, serializedBytes) {
+	if (!hasExactKeys(value, [
+		"type",
+		"seq0",
+		"time0",
+		"data"
+	])) malformed(tag, "invalid envelope fields");
+	if (!Number.isSafeInteger(value.seq0) || value.seq0 < 0) malformed(tag, "seq0 must be non-negative");
+	if (!Number.isSafeInteger(value.time0)) malformed(tag, "time0 must be a safe integer");
+	const data = value.data;
+	if (!isRecord(data)) malformed(tag, "data must be an object");
+	let payload;
+	if (tag === "tool-call-chunks") {
+		const withName = hasExactKeys(data, [
+			"turn",
+			"step",
+			"index",
+			"id",
+			"name",
+			"dt",
+			"args"
+		]);
+		if (!withName && !hasExactKeys(data, [
+			"turn",
+			"step",
+			"index",
+			"id",
+			"dt",
+			"args"
+		])) malformed(tag, "invalid tool-call data fields");
+		if (typeof data.id !== "string" || withName && typeof data.name !== "string") malformed(tag, "id and optional name must be strings");
+		payload = validateRunData(tag, data, "args", serializedBytes);
+	} else {
+		if (!hasExactKeys(data, [
+			"turn",
+			"step",
+			"index",
+			"dt",
+			"texts"
+		])) malformed(tag, "invalid text data fields");
+		payload = validateRunData(tag, data, "texts", serializedBytes);
+	}
+	if (!Number.isSafeInteger(value.seq0 + payload.length - 1)) malformed(tag, "member seqs exceed safe integers");
+	let time = value.time0;
+	for (const gap of data.dt) {
+		time += gap;
+		if (!Number.isSafeInteger(time)) malformed(tag, "member times exceed safe integers");
+	}
+	return value;
+}
+function expandRow(row) {
+	const members = row.type === "tool-call-chunks" ? row.data.args : row.data.texts;
+	const events = [];
+	let time = row.time0;
+	for (let index = 0; index < members.length; index += 1) {
+		if (index > 0) time += row.data.dt[index - 1];
+		let chunk;
+		switch (row.type) {
+			case "text-chunks":
+				chunk = {
+					type: "text-delta",
+					index: row.data.index,
+					text: members[index]
+				};
+				break;
+			case "reasoning-chunks":
+				chunk = {
+					type: "reasoning-delta",
+					index: row.data.index,
+					text: members[index]
+				};
+				break;
+			case "tool-call-chunks":
+				chunk = {
+					type: "tool-call-delta",
+					index: row.data.index,
+					id: row.data.id,
+					...Object.hasOwn(row.data, "name") ? { name: row.data.name } : {},
+					argumentsDelta: members[index]
+				};
+				break;
 		}
-		db.exec("COMMIT");
-		began = false;
-	} catch (error) {
-		/* v8 ignore next -- a BEGIN failure leaves no transaction to roll back. */
-		if (began)
- /* v8 ignore next 5 -- preserve the original schema failure if SQLite also refuses rollback. */
-		try {
-			db.exec("ROLLBACK");
-		} catch {}
-		throw error;
+		events.push({
+			type: "assistant/chunk",
+			seq: row.seq0 + index,
+			time,
+			data: {
+				turn: row.data.turn,
+				step: row.data.step,
+				chunk
+			}
+		});
 	}
-	db.exec(`PRAGMA journal_mode = ${journalMode.toUpperCase()}`);
+	return events;
 }
 /**
-* Reconstruct the {@link SessionHeader} from a `sessions` row.
-* @param row - the `sessions` table row.
-* @returns the header, `NULL` columns mapped to omitted optional fields.
+* Decode one packed row from its exact uncompressed data value. The byte bound
+* rejects oversized input before JSON parsing and avoids serializing it again.
+* @param tag - validated packed physical type.
+* @param seq0 - first represented logical sequence number.
+* @param time0 - first represented logical timestamp.
+* @param serializedData - decoded SQLite data-column text.
+* @returns the represented logical events.
 */
-function rowToMeta(row) {
-	if (!Number.isSafeInteger(row.created_at) || row.created_at < 0) throw new Error("stored session createdAt must be a non-negative safe integer");
-	return {
-		version: row.version,
-		id: row.id,
-		createdAt: row.created_at,
-		...row.cwd !== null ? { cwd: row.cwd } : {},
-		...row.parent_session !== null ? { parentSession: row.parent_session } : {},
-		...row.seed_length !== null ? { seedLength: row.seed_length } : {},
-		...row.origin !== null ? { origin: row.origin } : {},
-		...row.delegation_depth !== null ? { delegationDepth: row.delegation_depth } : {},
-		...row.agent_preset !== null ? { agentPreset: row.agent_preset } : {}
-	};
+function decodeSerializedChunkRow(tag, seq0, time0, serializedData) {
+	const bytes = Buffer.byteLength(serializedData);
+	if (bytes > 1048576) malformed(tag, `data exceeds ${MAX_PACKED_DATA_BYTES} UTF-8 bytes`);
+	return expandRow(validateRow({
+		type: tag,
+		seq0,
+		time0,
+		data: JSON.parse(serializedData)
+	}, tag, bytes));
+}
+const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+const MAX_ZIGZAG_INTEGER = MAX_SAFE_INTEGER * 2n;
+const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+const ZSTD_COMPRESSION_LEVEL = 3;
+const PACKED_ROW_SENTINEL = 0;
+const CHUNK_TAGS = [
+	"text-chunks",
+	"reasoning-chunks",
+	"tool-call-chunks"
+];
+function isChunkTag(value) {
+	return CHUNK_TAGS.includes(value);
+}
+/**
+* Decode one physical SQLite row into its complete logical event span.
+* @param row - detached SQLite event row.
+* @returns every logical event represented by the row.
+*/
+function decodeRow(row) {
+	if (row.ignorable !== PACKED_ROW_SENTINEL) return [decodeScalarRow(row)];
+	if (!isChunkTag(row.type)) throw new Error(`malformed ${row.type} storage row: packed discriminator requires a chunk tag`);
+	if (row.source_event_seqs !== null || row.surface_op !== null) throw new Error(`malformed ${row.type} storage row: packed surface fields must be null`);
+	return decodeSerializedChunkRow(row.type, row.seq, row.time, decodeData(row.data, MAX_PACKED_DATA_BYTES));
 }
 /**
-* Reconstruct a {@link SessionEvent} from an `events` row (parses `data`).
-* @param row - the `events` table row; `data` and the surface columns hold JSON text.
-* @returns the reconstructed event; throws when a JSON column fails to parse
-*   ({@link scanRows} treats that as a hole, not corruption, in the tail).
+* Convert a storage record to SQLite column values.
+* @param record - scalar event or packed chunk record.
+* @returns column values for one physical insert.
 */
-function rowToEvent(row) {
+function bindRecord(record) {
+	if (isChunkRow(record)) return {
+		seq: record.seq0,
+		type: record.type,
+		time: record.time0,
+		data: encodeData(JSON.stringify(record.data)),
+		sourceEventSeqs: null,
+		surfaceOp: null,
+		ignorable: PACKED_ROW_SENTINEL
+	};
+	const event = record;
+	const surface = event;
+	return {
+		seq: event.seq,
+		type: event.type,
+		time: event.time,
+		data: encodeData(JSON.stringify(event.data)),
+		sourceEventSeqs: surface.sourceEventSeqs === void 0 ? null : encodeSourceEventSeqs(surface.sourceEventSeqs),
+		surfaceOp: surface.surfaceOp === void 0 ? null : JSON.stringify(surface.surfaceOp),
+		ignorable: event.ignorable === true ? 1 : null
+	};
+}
+function encodeData(serialized) {
+	const bytes = Buffer.from(serialized);
+	if (bytes.length < 4096) return serialized;
+	const compressed = zstdCompressSync(bytes, { params: { [constants.ZSTD_c_compressionLevel]: ZSTD_COMPRESSION_LEVEL } });
+	return compressed.length < bytes.length ? compressed : serialized;
+}
+function decodeData(value, maxOutputLength) {
+	if (typeof value === "string") return value;
+	const decoded = maxOutputLength === void 0 ? zstdDecompressSync(value) : zstdDecompressSync(value, { maxOutputLength });
+	return UTF8_DECODER.decode(decoded);
+}
+function encodeSourceEventSeqs(values) {
+	const bytes = [];
+	let previous = 0n;
+	for (let index = 0; index < values.length; index += 1) {
+		const sourceSeq = values[index];
+		if (!Number.isSafeInteger(sourceSeq) || sourceSeq < 0) throw new TypeError("sourceEventSeqs must contain non-negative safe integers");
+		const value = BigInt(sourceSeq);
+		appendVarint(bytes, index === 0 ? value : value >= previous ? (value - previous) * 2n : (previous - value) * 2n - 1n);
+		previous = value;
+	}
+	return Buffer.from(bytes);
+}
+function appendVarint(bytes, value) {
+	let remaining = value;
+	while (remaining >= 128n) {
+		bytes.push(Number(remaining & 127n) | 128);
+		remaining >>= 7n;
+	}
+	bytes.push(Number(remaining));
+}
+function decodeSourceEventSeqs(bytes) {
+	const values = [];
+	let previous = 0n;
+	let offset = 0;
+	while (offset < bytes.length) {
+		const first = values.length === 0;
+		const decoded = readVarint(bytes, offset, first ? MAX_SAFE_INTEGER : MAX_ZIGZAG_INTEGER);
+		offset = decoded.offset;
+		const delta = first ? decoded.value : (decoded.value & 1n) === 0n ? decoded.value / 2n : -((decoded.value + 1n) / 2n);
+		const value = first ? delta : previous + delta;
+		if (value < 0n || value > MAX_SAFE_INTEGER) throw new Error("malformed source_event_seqs storage value: decoded seq is out of range");
+		values.push(Number(value));
+		previous = value;
+	}
+	return values;
+}
+function readVarint(bytes, offset, limit) {
+	let value = 0n;
+	let shift = 0n;
+	while (offset < bytes.length) {
+		const byte = bytes[offset];
+		offset += 1;
+		value |= BigInt(byte & 127) << shift;
+		if ((byte & 128) === 0) {
+			if (shift > 0n && (byte & 127) === 0) throw new Error("malformed source_event_seqs storage value: non-canonical varint");
+			if (value > limit) throw new Error("malformed source_event_seqs storage value: varint is out of range");
+			return {
+				value,
+				offset
+			};
+		}
+		shift += 7n;
+		if (shift > 56n) throw new Error("malformed source_event_seqs storage value: varint is out of range");
+	}
+	throw new Error("malformed source_event_seqs storage value: truncated varint");
+}
+function isChunkRow(record) {
+	return isChunkTag(record.type) && "seq0" in record && !("seq" in record);
+}
+function decodeScalarRow(row) {
 	const surfaceFields = {
-		...row.source_event_seqs !== null ? { sourceEventSeqs: JSON.parse(row.source_event_seqs) } : {},
-		...row.surface_op !== null ? { surfaceOp: JSON.parse(row.surface_op) } : {}
+		...row.source_event_seqs === null ? {} : { sourceEventSeqs: decodeSourceEventSeqs(row.source_event_seqs) },
+		...row.surface_op === null ? {} : { surfaceOp: JSON.parse(row.surface_op) }
 	};
-	const ignorableField = row.ignorable === 1 ? { ignorable: true } : {};
 	return {
 		type: row.type,
 		seq: row.seq,
 		time: row.time,
-		data: JSON.parse(row.data),
+		data: JSON.parse(decodeData(row.data)),
 		...surfaceFields,
-		...ignorableField
+		...row.ignorable === 1 ? { ignorable: true } : {}
 	};
 }
 /**
-* Find the preserved prefix of ordered event rows. Fully written rows in an
-* interrupted final turn remain in the prefix. The first unparsable row or seq
-* gap after the last `turn/end` marks a tolerated torn tail; the same hole in
-* the committed region rejects.
-*
-* @param rows - one session's event rows, ordered by seq ascending.
-* @param base - the seq the first row is expected to carry; `0` for a whole
-*   log, the requested `fromSeq` for a suffix read (`loadStoredFrom`).
-* @returns the preserved event prefix, plus `tornFrom` — the seq the physical
-*   delete starts at — when a torn tail exists.
+* Validate and flatten physical rows into their logical prefix. A malformed
+* row or logical gap is committed corruption when a later valid turn end
+* exists; otherwise it starts a removable physical tail.
+* @param rows - physical rows ordered by their first logical sequence.
+* @param base - logical sequence expected from the first selected row.
+* @returns the contiguous logical prefix and optional physical deletion base.
 */
 function scanRows(rows, base = 0) {
-	const parsed = rows.map((row) => {
+	let lastTurnEndRow = -1;
+	for (let index = rows.length - 1; index >= 0; index -= 1) try {
+		if (decodeRow(rows[index]).some((event) => event.type === "turn/end")) {
+			lastTurnEndRow = index;
+			break;
+		}
+	} catch {}
+	const preserved = [];
+	let expected = base;
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+		const physical = rows[rowIndex];
+		let logicalEvents;
 		try {
+			logicalEvents = decodeRow(physical);
+		} catch {}
+		if (logicalEvents === void 0) {
+			if (rowIndex <= lastTurnEndRow) throw new Error(`corrupt session log: invalid committed physical row at seq ${physical.seq}`);
 			return {
-				ok: true,
-				event: rowToEvent(row)
+				preserved,
+				tornFrom: physical.seq
 			};
-		} catch {
-			return { ok: false };
 		}
-	});
-	let lastTurnEnd = -1;
-	for (let i = parsed.length - 1; i >= 0; i--) if (parsed[i]?.ok && rows[i]?.type === "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]?.seq}`);
-			break;
+		let contiguous = true;
+		for (const event of logicalEvents) {
+			if (event.seq !== expected) {
+				contiguous = false;
+				break;
+			}
+			expected += 1;
 		}
-		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;
+		if (!contiguous) {
+			if (rowIndex <= lastTurnEndRow) throw new Error(`corrupt session log: invalid committed physical row at seq ${physical.seq}`);
+			return {
+				preserved,
+				tornFrom: physical.seq
+			};
 		}
-		preserved.push(p.event);
+		preserved.push(...logicalEvents);
 	}
-	return preserved.length < rows.length ? {
-		preserved,
-		tornFrom: base + preserved.length
-	} : { preserved };
+	return { preserved };
 }
 //#endregion
-//#region lib/types/index.js
+//#region lib/types/sql.js
 /**
-* SQLite durable session-persistence backend. It maps each session header and
-* event to rows, and delegates write-path orchestration to
-* {@link PersistenceCoordinator}. It has no independent per-session artifact,
-* so its locator returns `undefined`.
-* @module @nomix-ai/nomix-session-persistence-sqlite
+* Closed, package-owned SQL resource loading for SQLite.
+* @module @nomix-ai/nomix-session-persistence-sqlite/sql
 */
+const cache = /* @__PURE__ */ new Map();
 /**
-* Serialize an event's optional envelope fields for SQL binding. The surface
-* fields are nullable TEXT columns — null when the event has no surface
-* metadata (non-surface events, events written before surface support); the
-* ignorable marker is a nullable INTEGER column — `1` iff the envelope carries
-* `ignorable: true`.
+* Load an immutable SQL statement by closed resource name.
+* @param name - package-owned resource basename.
+* @returns the resource text.
 */
-function envelopeBindings(event) {
-	const se = event;
-	return [
-		se.sourceEventSeqs ? JSON.stringify(se.sourceEventSeqs) : null,
-		se.surfaceOp !== void 0 ? JSON.stringify(se.surfaceOp) : null,
-		event.ignorable === true ? 1 : null
-	];
-}
-/** Build the source-qualified revision shared by full and lightweight reads. */
-function sqliteRevision(storeIdentity, row) {
-	return SessionPersistenceRevision(`${storeIdentity}:incarnation:${row.incarnation}:revision:${row.revision}`);
+function sql(name) {
+	const cached = cache.get(name);
+	if (cached !== void 0) return cached;
+	const statement = readFileSync(fileURLToPath(new URL(`../resources/sql/${name}.sql`, import.meta.url)), "utf8");
+	cache.set(name, statement);
+	return statement;
 }
+//#endregion
+//#region lib/types/schema.js
 /**
-* Exclusively create a missing database file with owner-only permissions.
-* Existing files retain their modes, and errors other than `EEXIST` propagate.
-* `DatabaseSync` reopens by path, so this does not protect confidentiality or
-* integrity when another principal can replace the database entry in its parent
-* directory.
+* SQLite schema ownership and durable-row validation.
+* @module @nomix-ai/nomix-session-persistence-sqlite/schema
 */
-async function createDatabaseFile(path) {
+/** Current physical-record schema with packed and compressed event rows. */
+const SCHEMA_VERSION = 17;
+/** Application id reserved for Nomix Harness SQLite session databases. */
+const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const JOURNAL_BUSY_RETRY_INTERVAL_MS = 10;
+/**
+* Open and validate a SQLite session database.
+* @param Database - lazily imported Node SQLite constructor.
+* @param path - SQLite path, including `:memory:`.
+* @param journalMode - validated journal pragma.
+* @param busyTimeoutMs - validated maximum wait for a competing SQLite lock.
+* @returns the configured database handle.
+* @throws when connection settings, schema ownership, or SQLite setup cannot be validated.
+*/
+async function openDatabase(Database, path, journalMode, busyTimeoutMs) {
+	const deadline = performance.now() + busyTimeoutMs;
+	const db = new Database(path, { timeout: busyTimeoutMs });
 	try {
-		await (await open(path, "wx", 384)).close();
+		configureConnectionSecurity(db, path);
+		configureDatabase(Database, db, path);
+		await selectJournalMode(db, path, journalMode, deadline);
+		configureDurability(db, path);
+		return db;
 	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
+		db.close();
+		throw error;
+	}
+}
+function configureConnectionSecurity(db, path) {
+	db.exec(sql("trusted-schema-off"));
+	const trustedSchema = integerField(db.prepare(sql("select-trusted-schema")).get(), "trusted_schema");
+	/* v8 ignore next 3 -- supported SQLite versions return the fixed setting. */
+	if (trustedSchema !== 0) throw new Error(`session database at "${path}" retained trusted_schema=${trustedSchema}, expected 0`);
+	db.exec(sql("mmap-off"));
+	if (path === ":memory:") return;
+	const mmapSize = integerField(db.prepare(sql("select-mmap-size")).get(), "mmap_size");
+	/* v8 ignore next 3 -- supported file-backed SQLite connections return the fixed setting. */
+	if (mmapSize !== 0) throw new Error(`session database at "${path}" retained mmap_size=${mmapSize}, expected 0`);
+}
+function configureDatabase(Database, db, path) {
+	db.exec(sql("foreign-keys-on"));
+	let began = false;
+	try {
+		db.exec(sql("begin-immediate"));
+		began = true;
+		const onDisk = integerField(db.prepare(sql("select-user-version")).get(), "user_version");
+		const applicationId = integerField(db.prepare(sql("select-application-id")).get(), "application_id");
+		const userObjectCount = integerField(db.prepare(sql("select-user-object-count")).get(), "count");
+		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 !== 17) throw new Error(`session database at "${path}" has schema version ${onDisk}, incompatible with this build (17)`);
+		if (onDisk !== 0 && applicationId !== 1146308688) throw new Error(`session database at "${path}" has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
+		if (onDisk === 0) initializeDatabase(db);
+		validateRequiredSchema(Database, db, path);
+		db.exec(sql("commit"));
+		began = false;
+	} catch (error) {
+		/* v8 ignore else -- a failed begin leaves no transaction to roll back. */
+		if (began)
+ /* v8 ignore next 5 -- retain the original ownership failure if rollback fails too. */
+		try {
+			db.exec(sql("rollback"));
+		} catch {}
+		throw error;
+	}
+}
+async function selectJournalMode(db, path, journalMode, deadline) {
+	let result;
+	while (true) try {
+		result = db.prepare(sql(journalResource(journalMode))).get();
+		break;
+	} catch (error) {
+		const remainingMs = Math.max(0, Math.ceil(deadline - performance.now()));
+		if (!isSqliteBusy(error) || remainingMs === 0) throw error;
+		await setTimeout(Math.min(JOURNAL_BUSY_RETRY_INTERVAL_MS, remainingMs));
+		if (performance.now() >= deadline) throw error;
+	}
+	const selected = stringField(result, "journal_mode").toLowerCase();
+	const expected = path === ":memory:" ? "memory" : journalMode;
+	/* v8 ignore next 3 -- SQLite returns the selected mode from these fixed, valid pragmas. */
+	if (selected !== expected) throw new Error(`session database at "${path}" selected journal mode ${selected}, expected ${expected}`);
+}
+function configureDurability(db, path) {
+	db.exec(sql("synchronous-full"));
+	const synchronous = integerField(db.prepare(sql("select-synchronous")).get(), "synchronous");
+	/* v8 ignore next 3 -- supported SQLite versions return the fixed setting. */
+	if (synchronous !== 2) throw new Error(`session database at "${path}" retained synchronous=${synchronous}, expected FULL (2)`);
+}
+function isSqliteBusy(error) {
+	return typeof error === "object" && error !== null && Reflect.get(error, "errcode") === 5;
+}
+function journalResource(mode) {
+	switch (mode) {
+		case "wal": return "journal-mode-wal";
+		case "delete": return "journal-mode-delete";
+		case "truncate": return "journal-mode-truncate";
+		case "persist": return "journal-mode-persist";
+	}
+}
+function initializeDatabase(db) {
+	db.exec(sql("schema"));
+	db.prepare(sql("insert-persistence-state")).run(randomUUID());
+	db.exec(sql("set-application-id"));
+	db.exec(sql("set-user-version-17"));
+}
+let canonicalSchema;
+function expectedSchema(Database) {
+	if (canonicalSchema !== void 0) return canonicalSchema;
+	const reference = new Database(":memory:");
+	try {
+		reference.exec(sql("foreign-keys-on"));
+		reference.exec(sql("schema"));
+		canonicalSchema = schemaObjects(reference);
+		return canonicalSchema;
+	} finally {
+		reference.close();
 	}
 }
+function schemaObjects(db) {
+	return db.prepare(sql("select-schema-objects")).all().map((value) => {
+		const row = record(value, "schema object");
+		return {
+			type: stringField(row, "type"),
+			name: stringField(row, "name"),
+			tbl_name: stringField(row, "tbl_name"),
+			sql: normalizeSql(stringField(row, "sql"))
+		};
+	});
+}
+function normalizeSql(value) {
+	return value.replaceAll(/\s+/gu, " ").trim();
+}
+function validateRequiredSchema(Database, db, path) {
+	if (JSON.stringify(schemaObjects(db)) !== JSON.stringify(expectedSchema(Database))) throw new Error(`session database at "${path}" does not contain the required schema objects`);
+}
 /**
-* The SQLite persistence backend. Load as a plugin; it registers as
-* `ctx.sessionPersistence` and (via the coordinator) installs the write-path
-* listeners. Its torn-tail marker is the seq to delete from.
+* Recheck schema ownership inside the caller's mutation transaction.
+* @param Database - constructor used to validate the canonical schema.
+* @param db - open owned database with an active immediate transaction.
+* @param path - database location used in ownership diagnostics.
+* @throws when another writer changed the application identity, schema, or version.
 */
-var SqliteSessionPersistence = class extends SessionPersistence {
-	config;
-	supportsRawArtifacts = false;
-	static inject = ["sessions"];
-	static Config = z.object({
-		path: z.string().required(),
-		journalMode: z.union([
-			"wal",
-			"delete",
-			"truncate",
-			"persist"
-		]).default("wal"),
-		preparedSessionCacheSize: z.number().step(1).min(1).default(DEFAULT_PREPARED_SESSION_CACHE_SIZE),
-		writeBatchMaxDelayMs: z.number().step(1).min(1).max(MAX_WRITE_BATCH_DELAY_MS).default(DEFAULT_WRITE_BATCH_MAX_DELAY_MS)
-	});
-	/**
-	* Backend label for the coordinator's dispose diagnostics. Intentionally
-	* shadows cordis `Service.name` (set to `'sessionPersistence'` by the base);
-	* see the JSONL backend for why this does not affect service resolution.
-	*/
+function validateSchemaForMutation(Database, db, path) {
+	const version = integerField(db.prepare(sql("select-user-version")).get(), "user_version");
+	const applicationId = integerField(db.prepare(sql("select-application-id")).get(), "application_id");
+	if (applicationId !== 1146308688) throw new Error(`session database application id changed before mutation (expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}, got ${applicationId})`);
+	validateRequiredSchema(Database, db, path);
+	if (version !== 17) throw new Error(`session database schema changed before mutation (expected 17, got ${version})`);
+}
+/**
+* Decode and validate one durable session row.
+* @param value - value returned by SQLite.
+* @returns a validated session row.
+*/
+function decodeSessionRow(value) {
+	const row = record(value, "stored session metadata");
+	const id = nonemptyStringField(row, "id");
+	const version = safeIntegerField(row, "version");
+	const cwd = nullableStringField(row, "cwd");
+	if (cwd !== null && !isAbsolute(cwd)) throw new Error("stored session cwd must be absolute");
+	const parent = nullableStringField(row, "parent_session");
+	const origin = nullableStringField(row, "origin");
+	if (origin !== null && origin !== "subagent") throw new Error("stored session origin must be subagent or null");
+	const incarnation = nonemptyStringField(row, "incarnation");
+	if (!UUID.test(incarnation)) throw new Error("stored session incarnation must be a UUID");
+	return {
+		id,
+		version,
+		created_at: nonnegativeSafeIntegerField(row, "created_at"),
+		cwd,
+		parent_session: parent,
+		seed_length: nullableNonnegativeSafeIntegerField(row, "seed_length"),
+		origin,
+		delegation_depth: nullableNonnegativeSafeIntegerField(row, "delegation_depth"),
+		agent_preset: nullableStringField(row, "agent_preset"),
+		incarnation,
+		revision: nonnegativeSafeIntegerField(row, "revision")
+	};
+}
+/**
+* Decode and validate one durable event row before JSON interpretation.
+* @param value - value returned by SQLite.
+* @returns a validated physical event row.
+*/
+function decodeEventRow(value) {
+	const row = record(value, "stored event");
+	const ignorable = nullableSafeIntegerField(row, "ignorable");
+	if (ignorable !== null && ignorable !== 0 && ignorable !== 1) throw new Error("stored event ignorable must be 0, 1, or null");
+	return {
+		seq: nonnegativeSafeIntegerField(row, "seq"),
+		type: nonemptyStringField(row, "type"),
+		time: safeIntegerField(row, "time"),
+		data: stringOrBlobField(row, "data"),
+		source_event_seqs: nullableBlobField(row, "source_event_seqs"),
+		surface_op: nullableStringField(row, "surface_op"),
+		ignorable
+	};
+}
+/**
+* Validate the singleton identity read from durable storage.
+* @param value - value returned by SQLite.
+* @returns the UUID store identity.
+*/
+function decodeStoreIdentity(value) {
+	const identity = nonemptyStringField(value, "store_id");
+	if (!UUID.test(identity)) throw new Error("stored store_id must be a UUID");
+	return identity;
+}
+/**
+* Reconstruct an immutable session header from a validated metadata row.
+* @param row - validated stored metadata row.
+* @returns the session header.
+*/
+function rowToMeta(row) {
+	return {
+		version: row.version,
+		id: SessionId(row.id),
+		createdAt: row.created_at,
+		...row.cwd === null ? {} : { cwd: row.cwd },
+		...row.parent_session === null ? {} : { parentSession: SessionId(row.parent_session) },
+		...row.seed_length === null ? {} : { seedLength: row.seed_length },
+		...row.origin === null ? {} : { origin: row.origin },
+		...row.delegation_depth === null ? {} : { delegationDepth: row.delegation_depth },
+		...row.agent_preset === null ? {} : { agentPreset: row.agent_preset }
+	};
+}
+function record(value, label) {
+	if (typeof value !== "object" || value === null) throw new Error(`${label} must be an object`);
+	return value;
+}
+function stringField(value, key) {
+	const field = record(value, "SQLite row")[key];
+	if (typeof field !== "string") throw new Error(`stored ${key} must be a string`);
+	return field;
+}
+function nonemptyStringField(value, key) {
+	const field = stringField(value, key);
+	if (field.length === 0) throw new Error(`stored ${key} must not be empty`);
+	return field;
+}
+function nullableStringField(value, key) {
+	const field = record(value, "SQLite row")[key];
+	if (field === null) return null;
+	if (typeof field !== "string") throw new Error(`stored ${key} must be a string or null`);
+	return field;
+}
+function stringOrBlobField(value, key) {
+	const field = record(value, "SQLite row")[key];
+	if (typeof field === "string" || field instanceof Uint8Array) return field;
+	throw new Error(`stored ${key} must be a string or blob`);
+}
+function nullableBlobField(value, key) {
+	const field = record(value, "SQLite row")[key];
+	if (field === null || field instanceof Uint8Array) return field;
+	throw new Error(`stored ${key} must be a blob or null`);
+}
+function integerField(value, key) {
+	const field = record(value, "SQLite row")[key];
+	if (!Number.isSafeInteger(field)) throw new Error(`stored ${key} must be a safe integer`);
+	return field;
+}
+function safeIntegerField(value, key) {
+	return integerField(value, key);
+}
+function nonnegativeSafeIntegerField(value, key) {
+	const field = integerField(value, key);
+	if (field < 0) throw new Error(`stored ${key} must be non-negative`);
+	return field;
+}
+function nullableSafeIntegerField(value, key) {
+	const field = record(value, "SQLite row")[key];
+	if (field === null) return null;
+	if (!Number.isSafeInteger(field)) throw new Error(`stored ${key} must be a safe integer or null`);
+	return field;
+}
+function nullableNonnegativeSafeIntegerField(value, key) {
+	const field = nullableSafeIntegerField(value, key);
+	if (field !== null && field < 0) throw new Error(`stored ${key} must be non-negative or null`);
+	return field;
+}
+//#endregion
+//#region lib/types/store.js
+/**
+* SQLite storage primitives: transactional append-batch packing, physical
+* reads, schema validation, revisions, repair, and lifecycle closure.
+* @module @nomix-ai/nomix-session-persistence-sqlite/store
+*/
+/** SQLite implementation of the coordinator's physical backend hooks. */
+var SqliteStore = class {
+	options;
 	name = "session-persistence-sqlite";
 	db;
+	databaseConstructor;
 	storeIdentity;
+	databasePath;
+	opened = false;
+	pathReady;
 	ready;
-	coordinator;
-	constructor(ctx, config) {
-		super(ctx);
-		this.config = config;
-		const preparedSessionCacheSize = config.preparedSessionCacheSize ?? DEFAULT_PREPARED_SESSION_CACHE_SIZE;
-		const writeBatchMaxDelayMs = config.writeBatchMaxDelayMs ?? DEFAULT_WRITE_BATCH_MAX_DELAY_MS;
-		this.ready = this.openDb(config.path, config.journalMode);
-		this.coordinator = new PersistenceCoordinator(this.ctx, this, {
-			preparedSessionCacheSize,
-			writeBatchMaxDelayMs
-		});
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Validate filesystem ownership without importing or opening Node SQLite.
+	* @returns settlement of the store's one path-validation operation.
+	*/
+	validatePath() {
+		this.pathReady ??= this.preparePath(this.options.path);
+		return this.pathReady;
 	}
-	async openDb(path, journalMode) {
+	/**
+	* Lazily open and validate the database on first persistence use.
+	* @returns settlement of the store's one database-open operation.
+	*/
+	open() {
+		this.ready ??= this.openDb();
+		return this.ready;
+	}
+	async preparePath(path) {
 		const actual = path === ":memory:" ? path : resolve(path);
 		if (actual !== ":memory:") {
 			await mkdir(dirname(actual), {
 				recursive: true,
 				mode: 448
 			});
-			await createDatabaseFile(actual);
+			await validateParentDirectory(dirname(actual));
+			await validateDatabaseFileIfPresent(actual);
 		}
-		this.db = openDatabase(actual, journalMode);
+		this.databasePath = actual;
+	}
+	async openDb() {
+		await this.validatePath();
+		if (this.databasePath !== ":memory:") {
+			await createDatabaseFile(this.databasePath);
+			await validateDatabaseFile(this.databasePath);
+		}
+		const { DatabaseSync } = await loadNodeSqlite();
+		this.databaseConstructor = DatabaseSync;
+		this.db = await openDatabase(DatabaseSync, this.databasePath, this.options.journalMode, this.options.busyTimeoutMs);
 		try {
-			const row = this.db.prepare("SELECT store_id FROM persistence_state WHERE singleton = 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.store_id.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.store_id}`;
-			} else this.storeIdentity = `memory:store:${row.store_id}`;
+			const row = this.db.prepare(sql("select-store-id")).get();
+			if (row === void 0) throw new Error(`session database at "${this.databasePath}" has no valid store identity`);
+			let storeId;
+			try {
+				storeId = decodeStoreIdentity(row);
+			} catch (error) {
+				throw new Error(`session database at "${this.databasePath}" has no valid store identity`, { cause: error });
+			}
+			if (this.databasePath === ":memory:") this.storeIdentity = `memory:store:${storeId}`;
+			else {
+				const identity = statSync(this.databasePath, { bigint: true });
+				this.storeIdentity = `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${storeId}`;
+			}
+			this.opened = true;
 		} catch (error) {
 			this.db.close();
 			throw error;
 		}
 	}
-	/** SQLite has one database, not an independent local artifact per session. */
-	locate(_meta) {}
-	create(meta) {
-		return this.coordinator.create(meta);
-	}
-	append(id, events) {
-		return this.coordinator.append(id, events);
-	}
-	prepare(id, signal) {
-		return this.coordinator.prepare(id, signal);
-	}
-	load(id) {
-		return this.coordinator.load(id);
-	}
-	inspect(id, signal) {
-		return this.coordinator.inspect(id, signal);
-	}
-	readFrom(id, fromSeq, signal) {
-		return this.coordinator.readFrom(id, fromSeq, signal);
-	}
-	/** Read a stored prefix by id (ids are globally unique — no scope to scan). */
-	loadStored(id, signal) {
-		return this.readPrefix(id, signal);
+	async loadStored(id, signal) {
+		await this.observe(signal);
+		const snapshot = this.readTransaction(() => {
+			const row = this.rowFor(id);
+			if (row === void 0) return void 0;
+			return {
+				row,
+				eventRows: this.db.prepare(sql("select-events")).all(id).map(decodeEventRow)
+			};
+		});
+		signal?.throwIfAborted();
+		if (snapshot === void 0) return void 0;
+		const scanned = scanRows(snapshot.eventRows);
+		return {
+			meta: rowToMeta(snapshot.row),
+			events: scanned.preserved,
+			revision: sqliteRevision(this.storeIdentity, snapshot.row),
+			...scanned.tornFrom === void 0 ? {} : { tornMarker: scanned.tornFrom }
+		};
 	}
-	/** Read one row's revision without loading its events. */
 	async readStoredRevision(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
+		await this.observe(signal);
 		const row = this.rowFor(id);
+		signal?.throwIfAborted();
 		return row === void 0 ? void 0 : sqliteRevision(this.storeIdentity, row);
 	}
-	/**
-	* Seek-capable suffix read: SQL selects `seq >= fromSeq` directly, so the
-	* read scales with the suffix, not the log. Torn rows past the preserved
-	* region are dropped, never repaired (non-mutating read).
-	*/
 	async loadStoredFrom(id, fromSeq, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const row = this.rowFor(id);
-		if (row === void 0) return void 0;
-		const meta = rowToMeta(row);
-		const eventRows = this.db.prepare("SELECT seq, type, time, data, source_event_seqs, surface_op, ignorable FROM events WHERE session_id = ? AND seq >= ? ORDER BY seq").all(id, fromSeq);
-		signal?.throwIfAborted();
-		const { preserved } = scanRows(eventRows, fromSeq);
-		return {
-			meta,
-			events: preserved
-		};
-	}
-	/**
-	* Read a session's row + ordered events into a {@link StoredPrefix}. The
-	* torn-tail marker is the seq from which a never-committed tail must be deleted
-	* (`scanRows` already returns it as `number | undefined`).
-	*/
-	async readPrefix(id, signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		this.db.exec("BEGIN");
-		let snapshot;
-		try {
+		await this.observe(signal);
+		const snapshot = this.readTransaction(() => {
 			const row = this.rowFor(id);
-			if (row !== void 0) snapshot = {
+			if (row === void 0) return void 0;
+			return {
 				row,
-				eventRows: this.db.prepare("SELECT seq, type, time, data, source_event_seqs, surface_op, ignorable FROM events WHERE session_id = ? ORDER BY seq").all(id)
+				...this.physicalSpanFrom(id, fromSeq)
 			};
-			this.db.exec("COMMIT");
-		} catch (error) {
-			/* v8 ignore start -- synchronous read failures only need transaction cleanup before propagation. */
-			this.db.exec("ROLLBACK");
-			throw error;
-		}
+		});
 		signal?.throwIfAborted();
 		if (snapshot === void 0) return void 0;
-		const { row, eventRows } = snapshot;
-		const { preserved, tornFrom } = scanRows(eventRows);
+		const { preserved } = scanRows(snapshot.eventRows, snapshot.base);
 		return {
-			meta: rowToMeta(row),
-			events: preserved,
-			revision: sqliteRevision(this.storeIdentity, row),
-			...tornFrom !== void 0 ? { tornMarker: tornFrom } : {}
+			meta: rowToMeta(snapshot.row),
+			events: preserved.filter((event) => event.seq >= fromSeq)
 		};
 	}
-	/**
-	* Durably append a batch in ONE transaction: materialize the sessions row (if
-	* lazy) and INSERT every event, or roll back entirely. The transaction is the
-	* atomicity + durability boundary, so a mid-batch failure (a UNIQUE violation
-	* on a duplicated seq) leaves the stored log untouched.
-	*/
 	async appendBatch(meta, events, isMaterialized) {
-		await this.ready;
-		const insertEvent = this.db.prepare("INSERT INTO events (session_id, seq, type, time, data, source_event_seqs, surface_op, ignorable) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-		this.db.exec("BEGIN");
+		await this.open();
+		if (events.length === 0) return;
+		this.db.exec(sql("begin-immediate"));
 		try {
+			validateSchemaForMutation(this.databaseConstructor, this.db, this.databasePath);
+			const tailRows = this.tailRows(meta.id);
+			const currentLast = this.logicalLastEvent(meta.id, tailRows);
+			const expected = currentLast === void 0 ? 0 : currentLast.seq + 1;
+			const first = events[0];
+			if (first.seq !== expected) throw new Error(`session ${meta.id} append starts at seq ${first.seq}, stored next seq is ${expected}`);
 			if (!isMaterialized) this.writeRow(meta);
-			for (const event of events) {
-				const [surfaceSeqs, surfaceOp, ignorable] = envelopeBindings(event);
-				insertEvent.run(meta.id, event.seq, event.type, event.time, JSON.stringify(event.data), surfaceSeqs, surfaceOp, ignorable);
-			}
-			this.db.prepare("UPDATE sessions SET revision = revision + 1 WHERE id = ?").run(meta.id);
-			this.db.exec("COMMIT");
+			const insert = this.insertStatement();
+			for (const record of packChunkRuns(events)) this.insertRecord(insert, meta.id, bindRecord(record));
+			this.incrementRevision(meta.id);
+			this.db.exec(sql("commit"));
 		} catch (error) {
-			this.db.exec("ROLLBACK");
-			throw error;
+			this.rollback(error, "append");
 		}
 	}
-	/**
-	* Make a crash repair durable in ONE transaction: DELETE the torn tail (from
-	* `tornMarker`) and INSERT the synthetic `closers`. After COMMIT the stored rows
-	* == the balanced log.
-	*/
 	async commitRepair(meta, tornMarker, closers) {
-		await this.ready;
-		this.db.exec("BEGIN");
+		await this.open();
+		if (tornMarker === void 0 && closers.length === 0) return;
+		this.db.exec(sql("begin-immediate"));
 		try {
-			if (tornMarker !== void 0) this.db.prepare("DELETE FROM events WHERE session_id = ? AND seq >= ?").run(meta.id, tornMarker);
+			validateSchemaForMutation(this.databaseConstructor, this.db, this.databasePath);
+			if (this.rowFor(meta.id) === void 0) throw new Error(`session ${meta.id} metadata row is missing`);
+			const current = scanRows(this.db.prepare(sql("select-events")).all(meta.id).map(decodeEventRow));
+			if (tornMarker !== void 0) {
+				if (current.tornFrom !== tornMarker) throw new Error(`session ${meta.id} repair is stale: physical tail no longer starts at seq ${tornMarker}`);
+				this.db.prepare(sql("delete-events-from")).run(meta.id, tornMarker);
+			} else if (current.tornFrom !== void 0) throw new Error(`session ${meta.id} repair omitted current torn tail at seq ${current.tornFrom}`);
 			if (closers.length > 0) {
-				const insertEvent = this.db.prepare("INSERT INTO events (session_id, seq, type, time, data, source_event_seqs, surface_op, ignorable) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-				for (const event of closers) {
-					const [surfaceSeqs, surfaceOp, ignorable] = envelopeBindings(event);
-					insertEvent.run(meta.id, event.seq, event.type, event.time, JSON.stringify(event.data), surfaceSeqs, surfaceOp, ignorable);
-				}
+				const expected = current.preserved.at(-1)?.seq === void 0 ? 0 : current.preserved.at(-1).seq + 1;
+				if (closers[0]?.seq !== expected) throw new Error(`session ${meta.id} repair is stale: closer starts at seq ${closers[0]?.seq}, stored next seq is ${expected}`);
+				const insert = this.insertStatement();
+				for (const closer of closers) this.insertRecord(insert, meta.id, bindRecord(closer));
 			}
-			if (tornMarker !== void 0 || closers.length > 0) this.db.prepare("UPDATE sessions SET revision = revision + 1 WHERE id = ?").run(meta.id);
-			this.db.exec("COMMIT");
+			this.incrementRevision(meta.id);
+			this.db.exec(sql("commit"));
 		} catch (error) {
-			/* v8 ignore start */
-			this.db.exec("ROLLBACK");
-			throw error;
+			this.rollback(error, "repair");
 		}
 	}
-	/** List all materialized sessions' metadata (every row is a materialized session). */
 	async list(signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const rows = this.db.prepare("SELECT * FROM sessions").all();
+		await this.observe(signal);
+		const rows = this.sessionRows();
 		signal?.throwIfAborted();
 		return rows.map(rowToMeta);
 	}
-	/** List metadata with a source-qualified monotonic revision per session. */
+	/**
+	* Return every materialized header with its source-qualified revision.
+	* @param signal - optional cancellation before or after the metadata query.
+	* @returns stored headers and revisions without loading event rows.
+	*/
 	async listSnapshots(signal) {
-		signal?.throwIfAborted();
-		await this.ready;
-		signal?.throwIfAborted();
-		const rows = this.db.prepare("SELECT * FROM sessions").all();
+		await this.observe(signal);
+		const rows = this.sessionRows();
 		signal?.throwIfAborted();
 		return rows.map((row) => ({
 			header: rowToMeta(row),
-			revision: SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.incarnation}:revision:${row.revision}`)
+			revision: sqliteRevision(this.storeIdentity, row)
 		}));
 	}
-	/** Close the database handle (awaited by the coordinator's dispose, post-drain). */
 	async close() {
-		await this.ready;
+		if (this.ready === void 0) {
+			if (this.pathReady !== void 0) await Promise.allSettled([this.pathReady]);
+			return;
+		}
+		await Promise.allSettled([this.ready]);
+		if (!this.opened) return;
+		this.opened = false;
 		this.db.close();
 	}
-	/** Fetch a session's row, or undefined if absent. */
 	rowFor(id) {
-		return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+		const value = this.db.prepare(sql("select-session")).get(id);
+		return value === void 0 ? void 0 : decodeSessionRow(value);
+	}
+	async observe(signal) {
+		signal?.throwIfAborted();
+		await this.open();
+		signal?.throwIfAborted();
+	}
+	readTransaction(read) {
+		this.db.exec(sql("begin"));
+		try {
+			const value = read();
+			this.db.exec(sql("commit"));
+			return value;
+		} catch (error) {
+			this.rollback(error, "read");
+		}
+	}
+	sessionRows() {
+		return this.db.prepare(sql("select-sessions")).all().map(decodeSessionRow);
+	}
+	rollback(error, operation) {
+		try {
+			this.db.exec(sql("rollback"));
+		} catch (rollbackError) {
+			/* v8 ignore next -- requires SQLite to fail both an operation and its immediate rollback. */
+			throw new AggregateError([error, rollbackError], `${this.name} ${operation} failed and rollback also failed`);
+		}
+		throw error;
+	}
+	incrementRevision(id) {
+		const updated = this.db.prepare(sql("update-session-revision")).run(id);
+		/* v8 ignore next -- materialized writes follow coordinator create(); other writes upsert in this transaction. */
+		if (Number(updated.changes) !== 1) throw new Error(`session ${id} metadata row is missing`);
+	}
+	tailRows(id) {
+		const tail = this.db.prepare(sql("select-tail-events")).all(id, 2).map(decodeEventRow).reverse();
+		if (tail.length === 0) return [];
+		return this.physicalSpanFrom(id, tail[0].seq).eventRows;
+	}
+	/** Select the bounded physical span that may represent `fromSeq`. */
+	physicalSpanFrom(id, fromSeq) {
+		const packedFloor = Math.max(0, fromSeq - MAX_PACKED_ROW_MEMBERS + 1);
+		const packedPredecessors = this.db.prepare(sql("select-packed-predecessors")).all(id, packedFloor, fromSeq).map(decodeEventRow);
+		let base = fromSeq;
+		for (const predecessor of packedPredecessors) try {
+			const last = decodeRow(predecessor).at(-1);
+			if (last !== void 0 && last.seq >= fromSeq) base = Math.min(base, predecessor.seq);
+		} catch {
+			base = Math.min(base, predecessor.seq);
+		}
+		const eventRows = this.db.prepare(sql("select-events-from")).all(id, base).map(decodeEventRow);
+		return {
+			base,
+			eventRows
+		};
+	}
+	logicalLastEvent(id, tailRows) {
+		if (tailRows.length === 0) return void 0;
+		const { preserved, tornFrom } = scanRows(tailRows, tailRows[0].seq);
+		if (tornFrom !== void 0) throw new Error(`session ${id} has an invalid physical tail at seq ${tornFrom}`);
+		return preserved.at(-1);
+	}
+	insertStatement() {
+		return this.db.prepare(sql("insert-event"));
+	}
+	insertRecord(insert, id, record) {
+		insert.run(id, record.seq, record.type, record.time, record.data, record.sourceEventSeqs, record.surfaceOp, record.ignorable);
 	}
-	/**
-	* Insert-or-replace a session's metadata row. The only caller is the first
-	* materializing `appendBatch`, so writing the row IS the materialization (its
-	* existence is the signal `list` reads).
-	*/
 	writeRow(meta) {
-		this.db.prepare(`
-      INSERT INTO sessions
-        (id, version, created_at, cwd, parent_session, seed_length, origin, delegation_depth, agent_preset, incarnation, revision)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
-      ON CONFLICT(id) DO UPDATE SET
-        version = excluded.version,
-        created_at = excluded.created_at,
-        cwd = excluded.cwd,
-        parent_session = excluded.parent_session,
-        seed_length = excluded.seed_length,
-        origin = excluded.origin,
-        delegation_depth = excluded.delegation_depth,
-        agent_preset = excluded.agent_preset
-    `).run(meta.id, meta.version, meta.createdAt, meta.cwd ?? null, meta.parentSession ?? null, meta.seedLength ?? null, meta.origin ?? null, meta.delegationDepth ?? null, meta.agentPreset ?? null, randomUUID());
+		this.db.prepare(sql("upsert-session")).run(meta.id, meta.version, meta.createdAt, meta.cwd ?? null, meta.parentSession ?? null, meta.seedLength ?? null, meta.origin ?? null, meta.delegationDepth ?? null, meta.agentPreset ?? null, randomUUID());
+	}
+};
+function sqliteRevision(storeIdentity, row) {
+	return SessionPersistenceRevision(`${storeIdentity}:incarnation:${row.incarnation}:revision:${row.revision}`);
+}
+async function createDatabaseFile(path) {
+	try {
+		await (await open(path, "wx", 384)).close();
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+	}
+}
+async function validateParentDirectory(path) {
+	const parent = await lstat(path);
+	if (parent.isSymbolicLink() || !parent.isDirectory()) throw new Error(`session database parent "${path}" must be a real directory`);
+	const uid = process.getuid?.();
+	/* v8 ignore start -- Windows exposes neither process.getuid nor meaningful
+	* uid/mode bits; POSIX tests cover owner and mode rejection. */
+	if (uid !== void 0 && (parent.uid !== uid || (parent.mode & 18) !== 0)) throw new Error(`session database parent "${path}" must be owned by the current user and not group/world-writable`);
+	/* v8 ignore stop */
+}
+async function validateDatabaseFile(path) {
+	const file = await lstat(path);
+	if (file.isSymbolicLink() || !file.isFile()) throw new Error(`session database "${path}" must be a regular file, not a symbolic link`);
+	const uid = process.getuid?.();
+	/* v8 ignore start -- Windows exposes neither process.getuid nor meaningful
+	* uid/mode bits; POSIX tests cover owner and mode rejection. */
+	if (uid !== void 0 && (file.uid !== uid || (file.mode & 63) !== 0)) throw new Error(`session database "${path}" must be owned by the current user and accessible only by that user`);
+	/* v8 ignore stop */
+}
+async function validateDatabaseFileIfPresent(path) {
+	try {
+		await validateDatabaseFile(path);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+let nodeSqlite;
+/** Load Node SQLite once so concurrent stores share one warning-filter lifetime. */
+function loadNodeSqlite() {
+	nodeSqlite ??= importNodeSqlite();
+	return nodeSqlite;
+}
+/** Import Node 22's SQLite dependency without its process-wide experimental warning. */
+async function importNodeSqlite() {
+	const emitWarning = Reflect.get(process, "emitWarning");
+	/* v8 ignore start -- Node 22 alone emits this warning; primary coverage runs on Node 24. */
+	const filteredEmitWarning = (warning, ...args) => {
+		const message = warning instanceof Error ? warning.message : warning;
+		const first = args[0];
+		const type = warning instanceof Error ? warning.name : typeof first === "string" ? first : typeof first === "object" && first !== null && "type" in first ? first.type : void 0;
+		if (message === "SQLite is an experimental feature and might change at any time" && type === "ExperimentalWarning") return;
+		Reflect.apply(emitWarning, process, [warning, ...args]);
+	};
+	Reflect.set(process, "emitWarning", filteredEmitWarning);
+	try {
+		return await import("node:sqlite");
+	} finally {
+		Reflect.set(process, "emitWarning", emitWarning);
+	}
+	/* v8 ignore stop */
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Opt-in SQLite persistence provider. Logical sessions remain unchanged;
+* the physical backend packs eligible chunk runs into schema-17 rows.
+* @module @nomix-ai/nomix-session-persistence-sqlite
+*/
+/** Default wait for another SQLite connection's write reservation. */
+const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+/** Largest busy timeout accepted by SQLite's signed millisecond interface. */
+const MAX_BUSY_TIMEOUT_MS = 2147483647;
+/**
+* SQLite `SessionPersistence` provider with a schema-owned physical codec.
+*/
+var SqliteSessionPersistence = class extends SessionPersistence {
+	config;
+	supportsRawArtifacts = false;
+	name = "session-persistence-sqlite";
+	static inject = ["sessions"];
+	static Config = z.object({
+		path: z.string().required(),
+		journalMode: z.union([
+			"wal",
+			"delete",
+			"truncate",
+			"persist"
+		]).default("wal"),
+		busyTimeoutMs: z.number().step(1).min(0).max(MAX_BUSY_TIMEOUT_MS).default(DEFAULT_BUSY_TIMEOUT_MS),
+		preparedSessionCacheSize: z.number().step(1).min(1).default(DEFAULT_PREPARED_SESSION_CACHE_SIZE),
+		writeBatchMaxDelayMs: z.number().step(1).min(1).max(MAX_WRITE_BATCH_DELAY_MS).default(DEFAULT_WRITE_BATCH_MAX_DELAY_MS)
+	});
+	store;
+	coordinator;
+	constructor(ctx, config) {
+		super(ctx);
+		this.config = config;
+		const preparedSessionCacheSize = config.preparedSessionCacheSize ?? DEFAULT_PREPARED_SESSION_CACHE_SIZE;
+		const writeBatchMaxDelayMs = config.writeBatchMaxDelayMs ?? DEFAULT_WRITE_BATCH_MAX_DELAY_MS;
+		this.store = new SqliteStore({
+			path: config.path,
+			journalMode: config.journalMode ?? "wal",
+			busyTimeoutMs: config.busyTimeoutMs ?? 5e3
+		});
+		this.coordinator = new PersistenceCoordinator(this.ctx, this.store, {
+			preparedSessionCacheSize,
+			writeBatchMaxDelayMs
+		});
+	}
+	/** Reject self-contained path and ownership failures without loading Node SQLite. */
+	async [Service.init]() {
+		await this.store.validatePath();
+	}
+	/** SQLite has one database, not an independent per-session artifact. */
+	locate(_meta) {}
+	create(meta) {
+		return this.coordinator.create(meta);
+	}
+	append(id, events) {
+		return this.coordinator.append(id, events);
+	}
+	prepare(id, signal) {
+		return this.coordinator.prepare(id, signal);
+	}
+	load(id) {
+		return this.coordinator.load(id);
+	}
+	inspect(id, signal) {
+		return this.coordinator.inspect(id, signal);
+	}
+	readFrom(id, fromSeq, signal) {
+		return this.coordinator.readFrom(id, fromSeq, signal);
+	}
+	list(signal) {
+		return this.store.list(signal);
+	}
+	listSnapshots(signal) {
+		return this.store.listSnapshots(signal);
 	}
 };
 //#endregion
-export { SCHEMA_VERSION, SqliteSessionPersistence, SqliteSessionPersistence as default };
+export { DEFAULT_BUSY_TIMEOUT_MS, MAX_BUSY_TIMEOUT_MS, SCHEMA_VERSION, SqliteSessionPersistence, SqliteSessionPersistence as default };