@earendil-works/pi-session-backend-sqlite-node 0.84.4 → 0.85.0

package/dist/sqlite/repo.js

@@ -1,750 +1,408 @@
-import { Session, SessionError, } from "@earendil-works/pi-agent-core";
+import { mkdir, open as openFile, readdir, realpath, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { branchTip, createForkSnapshot, StorageBackedSession } from "@earendil-works/pi-agent-core";
 import { uuidv7 } from "@earendil-works/pi-ai";
-import { appendEntryToBranchCache, buildCachedBranch, deleteBranchCache, rebuildBranchCache } from "./branch-cache.js";
-import { applyMigrations } from "./migrations.js";
+import { applyInitialSchema } from "./migrations.js";
+import { appendEntryToBranchIndex, scanBranchEntries } from "./session/branch-entries.js";
+import { decodeEntryRow, EntryRowWriter } from "./session/entries.js";
+import { deleteSessionRows, hasSessionRow, insertSessionRow, metadataFromSessionRow, readAllSessionRows, readSessionRow, } from "./session/session-row.js";
+import { readAllScalarValueRows, setScalarValueRow } from "./session/values.js";
+import { SqliteOpenSession } from "./session.js";
 import { sql } from "./sql.js";
-import { queryCachedBranchRows, readCachedBranch } from "./storage/branch-entries.js";
-import { readBranchTipIds } from "./storage/branch-tips.js";
-import { deleteEntryRows, entryPayload, idExistsInEntries, insertEntryRow, readEntryRow, readEntryRows, } from "./storage/entries.js";
-import { appendFact, deleteFactRows, readFactRows, readLatestFact, readLatestLabelFacts } from "./storage/facts.js";
-import { createInitialLane, deleteLaneRows, finishLaneOperation, createLane as insertLane, readLane, readLaneHead, readLaneMoveRows, readLanes, setLaneLeaf, startLaneOperation, moveLane as updateLane, } from "./storage/lanes.js";
-import { appendRecordRow, deleteRecordRows, idExistsInRecords, readOpenOperationRows, readRecordRows, } from "./storage/records.js";
-import { advanceSequence, createSequence, deleteSequence, getNextSequence, setNextSequence, } from "./storage/session-sequences.js";
-import { addUsageToStats, createStats, deleteStats, incrementMessageCount, readStats, } from "./storage/session-stats.js";
-import { decodeSessionMetadata, deleteSessionRow, insertSessionRow, readSessionRow, readSessionRows, sessionExists, } from "./storage/sessions.js";
-import { acquireWriterLease, deleteWriterLease, releaseWriterLease, renewWriterLease, } from "./storage/writer-leases.js";
-function resolveWriterLeaseOptions(options) {
-    const ttlMs = options?.ttlMs ?? 30_000;
-    const heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 10_000;
-    if (!Number.isSafeInteger(ttlMs) || ttlMs <= 0)
-        throw new RangeError("writerLease.ttlMs must be positive");
-    if (!Number.isSafeInteger(heartbeatIntervalMs) || heartbeatIntervalMs <= 0 || heartbeatIntervalMs >= ttlMs) {
-        throw new RangeError("writerLease.heartbeatIntervalMs must be positive and less than ttlMs");
-    }
-    return { ttlMs, heartbeatIntervalMs };
+import { SqliteStorage } from "./storage.js";
+export const SQLITE_STORAGE_VERSION = 1;
+export const SQLITE_SESSION_EXTENSION = ".sqlite";
+const FIRST_AVAILABLE_COMMIT_SEQ = 1;
+const SAFE_SESSION_FILE_ID = /^[A-Za-z0-9_-]+$/;
+function sessionFileName(id) {
+    if (SAFE_SESSION_FILE_ID.test(id))
+        return `${id}${SQLITE_SESSION_EXTENSION}`;
+    const encoded = Buffer.from(id, "utf16le").toString("base64url");
+    return `~${encoded}${SQLITE_SESSION_EXTENSION}`;
 }
-function activeWriterError(sessionId) {
-    return new SessionError("storage", `SQLite session ${sessionId} already has an active writer`);
+function sessionPath(directory, id) {
+    return join(directory, sessionFileName(id));
 }
-function lostWriterError(sessionId) {
-    return new SessionError("storage", `SQLite session ${sessionId} writer lease was lost`);
+function storageIdentity(path, sessionId) {
+    return JSON.stringify([path, sessionId]);
 }
-function claimWriterLease(db, sessionId, options) {
-    const now = Date.now();
-    const lease = acquireWriterLease(db, sessionId, uuidv7(), now, now + options.ttlMs);
-    if (!lease)
-        throw activeWriterError(sessionId);
-    return lease;
+function isErrorWithCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
-class SerialOperationQueue {
-    tail = Promise.resolve();
-    enqueue(operation) {
-        const result = this.tail.then(operation);
-        this.tail = result.then(() => undefined, () => undefined);
-        return result;
-    }
-    async drain() {
-        await this.tail;
-    }
-}
-function resultOrThrow(result, message) {
-    if (!result.ok) {
-        const code = result.error.code === "not_found" ? "not_found" : "storage";
-        throw new SessionError(code, `${message}: ${result.error.message}`, result.error);
-    }
-    return result.value;
+async function removeSessionFiles(path, options) {
+    await rm(path, { force: options.force });
+    await rm(`${path}-wal`, { force: true });
+    await rm(`${path}-shm`, { force: true });
 }
-function getParentPath(path) {
-    const normalized = path.replace(/[\\/]+$/, "");
-    const lastSlash = Math.max(normalized.lastIndexOf("/"), normalized.lastIndexOf("\\"));
-    if (lastSlash < 0)
-        return ".";
-    if (lastSlash === 0)
-        return normalized.slice(0, 1);
-    return normalized.slice(0, lastSlash);
+function configureWritableConnection(db) {
+    db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
 }
-function configureSqliteDatabase(db) {
-    sql `PRAGMA journal_mode=WAL`.exec(db);
-    sql `PRAGMA synchronous=FULL`.exec(db);
-    sql `PRAGMA busy_timeout=5000`.exec(db);
+function configureReadOnlyConnection(db) {
+    db.exec("PRAGMA busy_timeout = 5000;");
 }
-function entryRowFromCached(row) {
-    return { ...row, seq: row.entry_seq, type: row.type };
-}
-function readObjectPayload(row) {
-    const payload = JSON.parse(row.payload);
-    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
-        throw new Error("Payload is not an object");
-    }
-    return payload;
-}
-function decodeEntry(row) {
-    try {
-        const payload = readObjectPayload(row);
-        const base = { id: row.id, seq: row.seq, parentId: row.parent_id, timestamp: row.timestamp };
-        switch (row.type) {
-            case "message":
-                if (typeof payload.message !== "object" || payload.message === null)
-                    throw new Error("Missing message");
-                return {
-                    ...base,
-                    type: "message",
-                    message: payload.message,
-                    ...(payload.terminate === true ? { terminate: true } : {}),
-                };
-            case "model_change":
-                if (typeof payload.provider !== "string" || typeof payload.modelId !== "string") {
-                    throw new Error("Invalid model_change payload");
-                }
-                return { ...base, type: "model_change", provider: payload.provider, modelId: payload.modelId };
-            case "thinking_level_change":
-                if (typeof payload.thinkingLevel !== "string")
-                    throw new Error("Invalid thinking_level_change payload");
-                return { ...base, type: "thinking_level_change", thinkingLevel: payload.thinkingLevel };
-            case "active_tools_change":
-                if (!Array.isArray(payload.activeToolNames))
-                    throw new Error("Invalid active_tools_change payload");
-                if (payload.activeToolNames.some((value) => typeof value !== "string")) {
-                    throw new Error("Invalid active_tools_change payload");
-                }
-                return { ...base, type: "active_tools_change", activeToolNames: payload.activeToolNames };
-            case "compaction":
-                if (typeof payload.summary !== "string" ||
-                    !Array.isArray(payload.retainedTail) ||
-                    typeof payload.tokensBefore !== "number") {
-                    throw new Error("Invalid compaction payload");
-                }
-                return {
-                    ...base,
-                    type: "compaction",
-                    summary: payload.summary,
-                    retainedTail: payload.retainedTail,
-                    tokensBefore: payload.tokensBefore,
-                    ...(Object.hasOwn(payload, "details") ? { details: payload.details } : {}),
-                    ...(Object.hasOwn(payload, "usage")
-                        ? { usage: payload.usage }
-                        : {}),
-                };
-            case "branch_summary":
-                if (typeof payload.fromId !== "string" || typeof payload.summary !== "string") {
-                    throw new Error("Invalid branch_summary payload");
-                }
-                return {
-                    ...base,
-                    type: "branch_summary",
-                    fromId: payload.fromId,
-                    summary: payload.summary,
-                    ...(Object.hasOwn(payload, "details") ? { details: payload.details } : {}),
-                    ...(Object.hasOwn(payload, "usage")
-                        ? { usage: payload.usage }
-                        : {}),
-                };
-            case "custom":
-                if (typeof payload.customType !== "string")
-                    throw new Error("Invalid custom payload");
-                return {
-                    ...base,
-                    type: "custom",
-                    customType: payload.customType,
-                    ...(Object.hasOwn(payload, "data") ? { data: payload.data } : {}),
-                };
-        }
-    }
-    catch (error) {
-        throw new SessionError("invalid_entry", `Invalid SQLite session entry ${row.id}: failed to decode entry ${row.id}`, error instanceof Error ? error : undefined);
-    }
+function readSourceEntries(db, sessionId) {
+    return sql `SELECT id, parent_id, seq, type, custom_type, timestamp, payload
+		FROM entries WHERE session_id = ${sessionId} ORDER BY seq ASC`
+        .all(db)
+        .map(decodeEntryRow);
 }
-function recordRunId(record) {
-    return record.type === "operation_started" ? record.id : "runId" in record ? record.runId : undefined;
+function buildForkSnapshot(source, options) {
+    const snapshot = createForkSnapshot({
+        entries: source.entries,
+        scalarValues: source.scalarValues,
+        entriesComplete: source.entriesComplete,
+    }, options);
+    const entries = [...snapshot.entries.values()].sort((left, right) => left.seq - right.seq);
+    return {
+        entries,
+        scalarValues: snapshot.scalarValues,
+        messageCount: entries.filter((entry) => entry.type === "message").length,
+        nextSeq: snapshot.nextSeq,
+    };
 }
-function recordOpKind(record) {
-    return record.type === "operation_started" ? record.intent.kind : undefined;
+// TODO(WP08): Remove this snapshot path when SQLite forks use streaming staging.
+function readForkSourceEntries(db, sessionId, scalarValues, options) {
+    if (options.scope === "tree")
+        return readSourceEntries(db, sessionId);
+    const sourceAddress = branchTip(options.branch);
+    const sourceTip = scalarValues.find((stored) => stored.address.namespace === sourceAddress.namespace && stored.address.key === sourceAddress.key);
+    if (sourceTip === undefined)
+        throw new Error(`Unknown source branch: ${options.branch}`);
+    return sourceTip.value === null
+        ? []
+        : scanBranchEntries(db, sessionId, { start: sourceTip.value, order: "oldestFirst" });
 }
-function decodeRecord(row) {
+function createSqliteForkSnapshot(sourceDb, source, options) {
+    sourceDb.exec("BEGIN");
+    let committed = false;
     try {
-        return {
-            ...JSON.parse(row.payload),
-            seq: row.seq,
-            timestamp: row.timestamp,
-        };
+        metadataFromSessionRow(source.path, readSessionRow(sourceDb, source.id), SQLITE_STORAGE_VERSION);
+        const scalarValues = readAllScalarValueRows(sourceDb, source.id);
+        const snapshot = buildForkSnapshot({
+            entries: readForkSourceEntries(sourceDb, source.id, scalarValues, options),
+            scalarValues,
+            entriesComplete: options.scope === "tree",
+        }, options);
+        sourceDb.exec("COMMIT");
+        committed = true;
+        return snapshot;
     }
     catch (error) {
-        throw new SessionError("storage", `Invalid SQLite session record at sequence ${row.seq}: failed to decode payload`, error instanceof Error ? error : undefined);
+        if (!committed)
+            sourceDb.exec("ROLLBACK");
+        throw error;
     }
 }
-function validateCachedBranchRows(rows, query) {
-    if (rows.length === 0 || query.type !== undefined || query.customType !== undefined)
-        return;
-    const path = [...rows].sort((left, right) => left.entry_seq - right.entry_seq);
-    const shouldIncludeRoot = query.stopAtId === undefined &&
-        query.stopAtType === undefined &&
-        query.cursor === undefined &&
-        (query.order === "oldestFirst" || query.limit === undefined);
-    if (shouldIncludeRoot && path[0]?.parent_id !== null) {
-        throw new SessionError("invalid_entry", `Entry ${path[0]?.parent_id} not found`);
-    }
-    for (let index = 1; index < path.length; index++) {
-        const previous = path[index - 1];
-        const current = path[index];
-        if (current.parent_id !== previous.id) {
-            throw new SessionError("invalid_entry", `Entry ${current.parent_id} not found`);
-        }
-    }
+function insertForkValue(db, sessionId, stored) {
+    setScalarValueRow(db, sessionId, stored.address.namespace, stored.address.key, stored.seq, stored.value);
 }
-function matchesEntryQuery(entry, query) {
-    return ((query.type === undefined || entry.type === query.type) &&
-        (query.customType === undefined || (entry.type === "custom" && entry.customType === query.customType)) &&
-        (query.cursor === undefined ||
-            (query.order === "oldestFirst" ? entry.seq > query.cursor.afterSeq : entry.seq < query.cursor.afterSeq)));
-}
-function assertUnusedId(db, sessionId, id) {
-    if (idExistsInEntries(db, sessionId, id) || idExistsInRecords(db, sessionId, id)) {
-        throw new SessionError("already_exists", `ID already exists: ${id}`);
-    }
+function updateForkSessionStats(db, sessionId, messageCount) {
+    sql `UPDATE sessions SET message_count = ${messageCount} WHERE id = ${sessionId}`.run(db);
 }
-function requireSessionRow(db, sessionId) {
-    const row = readSessionRow(db, sessionId);
-    if (!row)
-        throw new SessionError("not_found", `Session not found: ${sessionId}`);
-    return row;
-}
-class SqliteSessionStorage {
-    db;
-    metadata;
-    lease;
-    leaseOptions;
-    onRelease;
-    operations = new SerialOperationQueue();
-    heartbeatTimer;
-    leaseError;
-    closing = false;
-    releasePromise;
-    constructor(db, metadata, lease, leaseOptions, onRelease) {
-        this.db = db;
-        this.metadata = metadata;
-        this.lease = lease;
-        this.leaseOptions = leaseOptions;
-        this.onRelease = onRelease;
-        this.scheduleHeartbeat();
-    }
-    async release() {
-        this.releasePromise ??= this.finishRelease();
-        await this.releasePromise;
-    }
-    async finishRelease() {
-        this.closing = true;
-        if (this.heartbeatTimer !== undefined)
-            clearTimeout(this.heartbeatTimer);
+export class SqliteSessionRepo {
+    directory;
+    databasePath;
+    databaseFactory;
+    now;
+    pendingIds = new Set();
+    openStorages = new Map();
+    openSessions = new Set();
+    closed = false;
+    closePromise;
+    constructor(options) {
+        this.directory = options.directory;
+        this.databasePath = options.databasePath;
+        this.databaseFactory = options.databaseFactory;
+        this.now = options.now ?? Date.now;
+    }
+    async create(options, _context) {
+        this.assertOpen();
+        options ??= {};
+        const createdAt = this.now();
+        const id = options.id ?? uuidv7(createdAt);
+        this.reserveId(id);
+        const path = this.pathForSession(id);
+        let db;
+        let reservedFile = false;
+        let initialized = false;
+        let session;
         try {
-            await this.operations.enqueue(() => this.db.transaction(() => releaseWriterLease(this.db, this.metadata.id, this.lease)));
+            await mkdir(dirname(path), { recursive: true });
+            if (!this.usesSharedDatabase()) {
+                const file = await openFile(path, "wx");
+                await file.close();
+                reservedFile = true;
+            }
+            const activeDb = await this.databaseFactory.open(path);
+            db = activeDb;
+            configureWritableConnection(activeDb);
+            await applyInitialSchema(activeDb);
+            const canonicalPath = await realpath(path);
+            const metadata = {
+                id,
+                createdAt,
+                storageVersion: SQLITE_STORAGE_VERSION,
+                ...(options.parentSessionId === undefined ? {} : { parentSessionId: options.parentSessionId }),
+                path: canonicalPath,
+            };
+            activeDb.transaction(() => {
+                if (hasSessionRow(activeDb, id))
+                    throw new Error(`SQLite session already exists: ${id}`);
+                insertSessionRow(activeDb, metadata, SQLITE_STORAGE_VERSION, FIRST_AVAILABLE_COMMIT_SEQ);
+            });
+            initialized = true;
+            session = this.openStorageBackedSession(metadata, activeDb);
+            return session;
+        }
+        catch (error) {
+            if (reservedFile && !initialized)
+                await removeSessionFiles(path, { force: true });
+            throw error;
         }
         finally {
-            this.onRelease();
+            if (session === undefined) {
+                try {
+                    db?.close();
+                }
+                finally {
+                    this.pendingIds.delete(id);
+                }
+            }
         }
     }
-    enqueueWrite(operation) {
-        if (this.closing)
-            return Promise.reject(new SessionError("storage", `SQLite session ${this.metadata.id} is closed`));
-        return this.operations.enqueue(() => {
-            if (this.leaseError)
-                throw this.leaseError;
-            return this.db.transaction(() => {
-                const now = Date.now();
-                if (!renewWriterLease(this.db, this.metadata.id, this.lease, now, now + this.leaseOptions.ttlMs)) {
-                    this.leaseError = lostWriterError(this.metadata.id);
-                    if (this.heartbeatTimer !== undefined)
-                        clearTimeout(this.heartbeatTimer);
-                    throw this.leaseError;
+    async open(metadata, _context) {
+        this.assertOpen();
+        this.reserveId(metadata.id);
+        let db;
+        let session;
+        try {
+            const path = await this.repositoryPathForMetadata(metadata);
+            const activeDb = await this.databaseFactory.openExisting(path);
+            db = activeDb;
+            configureWritableConnection(activeDb);
+            const stored = metadataFromSessionRow(path, readSessionRow(activeDb, metadata.id), SQLITE_STORAGE_VERSION);
+            session = this.openStorageBackedSession(stored, activeDb);
+            return session;
+        }
+        finally {
+            if (session === undefined) {
+                try {
+                    db?.close();
                 }
-                return operation();
-            });
-        });
+                finally {
+                    this.pendingIds.delete(metadata.id);
+                }
+            }
+        }
     }
-    scheduleHeartbeat() {
-        if (this.closing || this.leaseError)
-            return;
-        this.heartbeatTimer = setTimeout(async () => {
-            this.heartbeatTimer = undefined;
+    async list(_options, _context) {
+        this.assertOpen();
+        let paths;
+        if (this.usesSharedDatabase()) {
+            paths = [this.databasePath];
+        }
+        else {
+            let names;
             try {
-                await this.operations.enqueue(() => {
-                    if (this.closing || this.leaseError)
-                        return;
-                    this.db.transaction(() => {
-                        const now = Date.now();
-                        if (!renewWriterLease(this.db, this.metadata.id, this.lease, now, now + this.leaseOptions.ttlMs)) {
-                            this.leaseError = lostWriterError(this.metadata.id);
-                        }
-                    });
-                });
+                names = await readdir(this.directory);
+            }
+            catch (error) {
+                if (isErrorWithCode(error, "ENOENT"))
+                    return [];
+                throw error;
+            }
+            paths = names
+                .filter((name) => name.endsWith(SQLITE_SESSION_EXTENSION))
+                .map((name) => join(this.directory, name));
+        }
+        const sessions = [];
+        for (const path of paths) {
+            let db;
+            try {
+                const canonicalPath = await realpath(path);
+                db = await this.databaseFactory.openReadOnly(canonicalPath);
+                configureReadOnlyConnection(db);
+                for (const row of readAllSessionRows(db)) {
+                    sessions.push(metadataFromSessionRow(canonicalPath, row, SQLITE_STORAGE_VERSION));
+                }
             }
             catch {
-                // A transient heartbeat failure is retried. Every write still verifies ownership transactionally.
+                // Discovery is best-effort: corrupt files, incompatible versions, and
+                // unrelated *.sqlite files are reported when explicitly opened.
             }
             finally {
-                this.scheduleHeartbeat();
+                db?.close();
             }
-        }, this.leaseOptions.heartbeatIntervalMs);
-        this.heartbeatTimer.unref();
-    }
-    async getMetadata() {
-        return decodeSessionMetadata(requireSessionRow(this.db, this.metadata.id), this.metadata.path);
-    }
-    isForSession(sessionId) {
-        return this.metadata.id === sessionId;
-    }
-    async getLanes() {
-        return readLanes(this.db, this.metadata.id).map((row) => ({ lane: row.lane, leafId: row.leaf_id }));
+        }
+        return sessions.sort((left, right) => right.createdAt - left.createdAt);
     }
-    async createLane(lane, at) {
-        return this.enqueueWrite(() => {
-            if (readLane(this.db, this.metadata.id, lane)) {
-                throw new SessionError("already_exists", `Lane already exists: ${lane}`);
-            }
-            if (at !== null && !readEntryRow(this.db, this.metadata.id, at)) {
-                throw new SessionError("not_found", `Entry not found: ${at}`);
+    async delete(metadata, _context) {
+        this.assertOpen();
+        this.reserveId(metadata.id);
+        try {
+            const path = await this.repositoryPathForMetadata(metadata);
+            const db = await this.databaseFactory.openExisting(path);
+            try {
+                configureWritableConnection(db);
+                if (this.usesSharedDatabase()) {
+                    db.transaction(() => {
+                        metadataFromSessionRow(path, readSessionRow(db, metadata.id), SQLITE_STORAGE_VERSION);
+                        deleteSessionRows(db, metadata.id);
+                    });
+                }
+                else {
+                    metadataFromSessionRow(path, readSessionRow(db, metadata.id), SQLITE_STORAGE_VERSION);
+                }
             }
-            const seq = getNextSequence(this.db, this.metadata.id);
-            insertLane(this.db, this.metadata.id, seq, lane, at);
-            advanceSequence(this.db, this.metadata.id, seq);
-        });
-    }
-    async moveLane(lane, to) {
-        return this.enqueueWrite(() => {
-            if (!readLane(this.db, this.metadata.id, lane))
-                throw new SessionError("invalid_lane", `Lane not found: ${lane}`);
-            if (to !== null && !readEntryRow(this.db, this.metadata.id, to)) {
-                throw new SessionError("not_found", `Entry not found: ${to}`);
+            finally {
+                db.close();
             }
-            const seq = getNextSequence(this.db, this.metadata.id);
-            updateLane(this.db, this.metadata.id, seq, lane, to);
-            advanceSequence(this.db, this.metadata.id, seq);
-        });
-    }
-    async appendEntry(entry, lane) {
-        return this.enqueueWrite(() => {
-            const parentId = readLaneHead(this.db, this.metadata.id, lane).leafId;
-            assertUnusedId(this.db, this.metadata.id, entry.id);
-            const seq = getNextSequence(this.db, this.metadata.id);
-            const committed = { ...entry, parentId, seq, timestamp: Date.now() };
-            insertEntryRow(this.db, this.metadata.id, {
-                seq,
-                id: committed.id,
-                parentId: committed.parentId,
-                type: committed.type,
-                timestamp: committed.timestamp,
-                payload: JSON.stringify(entryPayload(committed)),
-            });
-            setLaneLeaf(this.db, this.metadata.id, lane, committed.id);
-            appendEntryToBranchCache(this.db, this.metadata.id, committed.id, seq, committed.type, committed.type === "custom" ? committed.customType : null, committed.parentId);
-            if (committed.type === "message")
-                incrementMessageCount(this.db, this.metadata.id);
-            advanceSequence(this.db, this.metadata.id, seq);
-            return structuredClone(committed);
-        });
+            if (!this.usesSharedDatabase())
+                await removeSessionFiles(path, { force: false });
+        }
+        finally {
+            this.pendingIds.delete(metadata.id);
+        }
     }
-    async appendRecord(record) {
-        return this.enqueueWrite(() => {
-            if (!readLane(this.db, this.metadata.id, record.lane)) {
-                throw new SessionError("invalid_lane", `Lane not found: ${record.lane}`);
-            }
-            assertUnusedId(this.db, this.metadata.id, record.id);
-            const seq = getNextSequence(this.db, this.metadata.id);
-            const committed = { ...record, seq, timestamp: Date.now() };
-            if (record.type === "operation_started") {
-                startLaneOperation(this.db, this.metadata.id, record.lane, record.id);
+    async fork(source, options, context) {
+        this.assertOpen();
+        const createdAt = this.now();
+        const id = options.id ?? uuidv7(createdAt);
+        this.reserveId(id);
+        const sourceStorage = this.openStorages.get(storageIdentity(source.path, source.id));
+        const activeSourceSnapshot = sourceStorage?.snapshot(options, context);
+        void activeSourceSnapshot?.catch(() => undefined);
+        const path = this.pathForSession(id);
+        let db;
+        let reservedFile = false;
+        let initialized = false;
+        let session;
+        try {
+            await mkdir(dirname(path), { recursive: true });
+            if (!this.usesSharedDatabase()) {
+                const file = await openFile(path, "wx");
+                await file.close();
+                reservedFile = true;
             }
-            appendRecordRow(this.db, this.metadata.id, {
-                seq,
-                id: record.id,
-                lane: record.lane,
-                runId: recordRunId(record),
-                type: record.type,
-                opKind: recordOpKind(record),
-                timestamp: committed.timestamp,
-                payload: JSON.stringify(record),
+            const snapshot = activeSourceSnapshot === undefined
+                ? await this.createForkSnapshotFromExternalSource(source, options)
+                : buildForkSnapshot(await activeSourceSnapshot, options);
+            const activeDb = await this.databaseFactory.open(path);
+            db = activeDb;
+            configureWritableConnection(activeDb);
+            await applyInitialSchema(activeDb);
+            const canonicalPath = await realpath(path);
+            const metadata = {
+                id,
+                createdAt,
+                storageVersion: SQLITE_STORAGE_VERSION,
+                parentSessionId: source.id,
+                path: canonicalPath,
+            };
+            activeDb.transaction(() => {
+                if (hasSessionRow(activeDb, id))
+                    throw new Error(`SQLite session already exists: ${id}`);
+                insertSessionRow(activeDb, metadata, SQLITE_STORAGE_VERSION, snapshot.nextSeq);
+                const entryWriter = new EntryRowWriter(activeDb, id);
+                for (const entry of snapshot.entries) {
+                    entryWriter.insert(entry);
+                    appendEntryToBranchIndex(activeDb, id, entry);
+                }
+                for (const stored of snapshot.scalarValues)
+                    insertForkValue(activeDb, id, stored);
+                updateForkSessionStats(activeDb, id, snapshot.messageCount);
             });
-            if (record.type === "operation_finished") {
-                finishLaneOperation(this.db, this.metadata.id, record.lane, record.runId);
-            }
-            if (record.type === "usage")
-                addUsageToStats(this.db, this.metadata.id, record.usage);
-            advanceSequence(this.db, this.metadata.id, seq);
-            return structuredClone(committed);
-        });
-    }
-    async getEntry(id) {
-        const row = readEntryRow(this.db, this.metadata.id, id);
-        return row ? decodeEntry(row) : undefined;
-    }
-    async findEntries(query = {}) {
-        const sqlType = query.type ?? (query.customType === undefined ? undefined : "custom");
-        const sqlLimit = query.customType === undefined ? query.limit : undefined;
-        const rows = readEntryRows(this.db, this.metadata.id, {
-            cursor: query.cursor,
-            limit: sqlLimit,
-            order: query.order,
-            type: sqlType,
-        });
-        const entries = rows.map(decodeEntry).filter((entry) => matchesEntryQuery(entry, query));
-        return query.limit === undefined ? entries : entries.slice(0, query.limit);
-    }
-    async findEntriesOnBranch(query) {
-        const cached = readCachedBranch(this.db, this.metadata.id, query.start);
-        if (!cached) {
-            if (!readEntryRow(this.db, this.metadata.id, query.start))
-                throw new SessionError("not_found", `Entry not found: ${query.start}`);
-            throw new SessionError("invalid_entry", `Branch cache missing entry ${query.start}`);
+            initialized = true;
+            session = this.openStorageBackedSession(metadata, activeDb);
+            return session;
         }
-        const rows = queryCachedBranchRows(this.db, this.metadata.id, cached, query);
-        validateCachedBranchRows(rows, query);
-        const entries = rows
-            .map(entryRowFromCached)
-            .map(decodeEntry)
-            .filter((entry) => matchesEntryQuery(entry, query));
-        return query.limit === undefined ? entries : entries.slice(0, query.limit);
-    }
-    async findRecords(query = {}) {
-        const rows = readRecordRows(this.db, this.metadata.id, query);
-        return rows.map(decodeRecord);
-    }
-    async findOpenOperations(lane, options) {
-        const rows = readOpenOperationRows(this.db, this.metadata.id, lane, options);
-        return rows.map((row) => {
-            const record = decodeRecord(row);
-            if (record.type !== "operation_started") {
-                throw new SessionError("storage", "Expected operation_started record");
-            }
-            return record;
-        });
-    }
-    async getLog(options = {}) {
-        const afterSeq = options.afterSeq ?? 0;
-        const limit = options.limit;
-        const entryRows = readEntryRows(this.db, this.metadata.id, { afterSeq, order: "oldestFirst", limit });
-        const recordRows = readRecordRows(this.db, this.metadata.id, { afterSeq, order: "oldestFirst", limit });
-        const laneRows = readLaneMoveRows(this.db, this.metadata.id, { afterSeq, limit });
-        const factRows = readFactRows(this.db, this.metadata.id, { afterSeq, limit });
-        const logRows = [
-            ...entryRows.map((row) => ({
-                seq: row.seq,
-                decode: () => ({ kind: "entry", seq: row.seq, entry: decodeEntry(row) }),
-            })),
-            ...recordRows.map((row) => ({
-                seq: row.seq,
-                decode: () => ({ kind: "record", seq: row.seq, record: decodeRecord(row) }),
-            })),
-            ...laneRows.map((row) => ({
-                seq: row.seq,
-                decode: () => ({ kind: "lane", seq: row.seq, lane: row.lane, leafId: row.leaf_id }),
-            })),
-            ...factRows.map((row) => ({
-                seq: row.seq,
-                decode: () => {
-                    if (row.kind === "name")
-                        return {
-                            kind: "fact",
-                            seq: row.seq,
-                            fact: "name",
-                            name: row.value === null ? undefined : JSON.parse(row.value),
-                        };
-                    return {
-                        kind: "fact",
-                        seq: row.seq,
-                        fact: "label",
-                        targetId: row.key ?? "",
-                        label: row.value === null ? undefined : JSON.parse(row.value),
-                    };
-                },
-            })),
-        ].sort((left, right) => left.seq - right.seq);
-        const selectedRows = options.limit === undefined ? logRows : logRows.slice(0, options.limit);
-        return selectedRows.map((row) => row.decode());
-    }
-    async getName() {
-        const row = readLatestFact(this.db, this.metadata.id, "name", null);
-        return row?.value === undefined || row.value === null ? undefined : JSON.parse(row.value);
-    }
-    async setName(name) {
-        return this.enqueueWrite(() => {
-            const seq = getNextSequence(this.db, this.metadata.id);
-            appendFact(this.db, this.metadata.id, seq, "name", null, name === undefined ? null : JSON.stringify(name));
-            advanceSequence(this.db, this.metadata.id, seq);
-        });
-    }
-    async getLabel(id) {
-        const row = readLatestFact(this.db, this.metadata.id, "label", id);
-        return row?.value === undefined || row.value === null ? undefined : JSON.parse(row.value);
-    }
-    async setLabel(id, label) {
-        return this.enqueueWrite(() => {
-            if (!readEntryRow(this.db, this.metadata.id, id)) {
-                throw new SessionError("not_found", `Entry not found: ${id}`);
+        catch (error) {
+            if (reservedFile && !initialized)
+                await removeSessionFiles(path, { force: true });
+            throw error;
+        }
+        finally {
+            if (session === undefined) {
+                try {
+                    db?.close();
+                }
+                finally {
+                    this.pendingIds.delete(id);
+                }
             }
-            const seq = getNextSequence(this.db, this.metadata.id);
-            appendFact(this.db, this.metadata.id, seq, "label", id, label === undefined ? null : JSON.stringify(label));
-            advanceSequence(this.db, this.metadata.id, seq);
-        });
-    }
-    async getStats() {
-        return readStats(this.db, this.metadata.id);
-    }
-}
-function claimStorage(db, metadata, leaseOptions, onRelease) {
-    requireSessionRow(db, metadata.id);
-    const claimed = db.transaction(() => {
-        const lease = claimWriterLease(db, metadata.id, leaseOptions);
-        const row = requireSessionRow(db, metadata.id);
-        readLanes(db, metadata.id);
-        return { lease, row };
-    });
-    return new SqliteSessionStorage(db, decodeSessionMetadata(claimed.row, metadata.path), claimed.lease, leaseOptions, onRelease);
-}
-export class SqliteSessionRepository {
-    databasePath;
-    database;
-    databasePromise;
-    operations = new SerialOperationQueue();
-    activeStorages = new Set();
-    options;
-    leaseOptions;
-    constructor(options) {
-        this.options = options;
-        this.leaseOptions = resolveWriterLeaseOptions(options.writerLease);
-    }
-    async releaseStoragesForSession(sessionId) {
-        for (const storage of [...this.activeStorages]) {
-            if (storage.isForSession(sessionId))
-                await storage.release();
         }
     }
-    sessionFromLease(db, metadata, lease) {
-        let storage;
-        storage = new SqliteSessionStorage(db, metadata, lease, this.leaseOptions, () => {
-            this.activeStorages.delete(storage);
-        });
-        this.activeStorages.add(storage);
-        return new Session(storage);
+    close(context) {
+        if (this.closePromise !== undefined)
+            return this.closePromise;
+        this.closed = true;
+        this.closePromise = this.closeOpenSessions(context);
+        return this.closePromise;
     }
-    claimSession(db, metadata) {
-        const active = [...this.activeStorages].find((storage) => storage.isForSession(metadata.id));
-        if (active) {
-            readLanes(db, metadata.id);
-            return new Session(active);
+    async createForkSnapshotFromExternalSource(source, options) {
+        const path = await realpath(source.path);
+        const sourceDb = await this.databaseFactory.openReadOnly(path);
+        try {
+            configureReadOnlyConnection(sourceDb);
+            return createSqliteForkSnapshot(sourceDb, { ...source, path }, options);
+        }
+        finally {
+            sourceDb.close();
         }
-        let storage;
-        storage = claimStorage(db, metadata, this.leaseOptions, () => {
-            this.activeStorages.delete(storage);
-        });
-        this.activeStorages.add(storage);
-        return new Session(storage);
-    }
-    async create(options) {
-        return this.operations.enqueue(async () => {
-            const db = await this.getDatabase();
-            const path = await this.getDatabasePath();
-            const id = options.id ?? uuidv7();
-            if (sessionExists(db, id))
-                throw new SessionError("already_exists", `Session already exists: ${id}`);
-            const createdAt = Date.now();
-            const lease = db.transaction(() => {
-                insertSessionRow(db, {
-                    id,
-                    createdAt,
-                    cwd: options.cwd,
-                    parentSessionId: options.parentSessionId,
-                    metadata: options.metadata,
-                });
-                createSequence(db, id);
-                createStats(db, id);
-                createInitialLane(db, id);
-                return claimWriterLease(db, id, this.leaseOptions);
-            });
-            const row = requireSessionRow(db, id);
-            return this.sessionFromLease(db, decodeSessionMetadata(row, path), lease);
-        });
-    }
-    async open(metadata) {
-        return this.operations.enqueue(async () => this.claimSession(await this.getDatabase(), metadata));
-    }
-    /** Rebuilds this session's private branch-read cache from canonical entry parent links. */
-    async repairBranchCache(metadata) {
-        return this.operations.enqueue(async () => {
-            await this.releaseStoragesForSession(metadata.id);
-            const db = await this.getDatabase();
-            db.transaction(() => {
-                const lease = claimWriterLease(db, metadata.id, this.leaseOptions);
-                requireSessionRow(db, metadata.id);
-                rebuildBranchCache(db, metadata.id);
-                releaseWriterLease(db, metadata.id, lease);
-            });
-        });
-    }
-    /** Reads the session catalog without acquiring or renewing per-session writer leases. */
-    async list(options = {}) {
-        return this.operations.enqueue(async () => {
-            const path = await this.getDatabasePath();
-            if (!resultOrThrow(await this.options.env.exists(path), `Failed to check database ${path}`))
-                return [];
-            const db = await this.getDatabase();
-            const rows = readSessionRows(db, options);
-            return rows.map((row) => decodeSessionMetadata(row, path));
-        });
-    }
-    async delete(metadata) {
-        return this.operations.enqueue(async () => {
-            await this.releaseStoragesForSession(metadata.id);
-            const db = await this.getDatabase();
-            db.transaction(() => {
-                if (!sessionExists(db, metadata.id)) {
-                    deleteWriterLease(db, metadata.id);
-                    return;
-                }
-                claimWriterLease(db, metadata.id, this.leaseOptions);
-                deleteBranchCache(db, metadata.id);
-                deleteFactRows(db, metadata.id);
-                deleteLaneRows(db, metadata.id);
-                deleteRecordRows(db, metadata.id);
-                deleteEntryRows(db, metadata.id);
-                deleteWriterLease(db, metadata.id);
-                deleteStats(db, metadata.id);
-                deleteSequence(db, metadata.id);
-                deleteSessionRow(db, metadata.id);
-            });
-        });
     }
-    async fork(source, options) {
-        return this.operations.enqueue(async () => {
-            const db = await this.getDatabase();
-            const path = await this.getDatabasePath();
-            const sourceMetadata = decodeSessionMetadata(requireSessionRow(db, source.id), path);
-            const id = options.id ?? uuidv7();
-            if (sessionExists(db, id))
-                throw new SessionError("already_exists", `Session already exists: ${id}`);
-            const entries = [];
-            const lanes = [];
-            const branchTips = [];
-            let branchForkTargetId = null;
-            if (options.scope === "tree") {
-                entries.push(...readEntryRows(db, source.id, { order: "oldestFirst" }));
-                lanes.push(...readLanes(db, source.id).map((row) => ({ lane: row.lane, leafId: row.leaf_id })));
-                branchTips.push(...readBranchTipIds(db, source.id));
-            }
-            else {
-                const main = readLane(db, source.id, "main");
-                if (!main)
-                    throw new SessionError("invalid_lane", "Lane not found: main");
-                const selectedEntryId = options.entryId ?? main.leaf_id;
-                if (selectedEntryId !== null) {
-                    const target = readEntryRow(db, source.id, selectedEntryId);
-                    if (!target || target.type !== "message") {
-                        throw new SessionError("invalid_fork_target", `Fork target is not a message entry: ${selectedEntryId}`);
-                    }
-                    const position = options.position ?? (options.entryId === undefined ? "at" : "before");
-                    branchForkTargetId = position === "at" ? target.id : target.parent_id;
+    async closeOpenSessions(context) {
+        const results = await Promise.allSettled([...this.openSessions].map((session) => session.close(context)));
+        const errors = results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "Failed to close SQLite Sessions");
+    }
+    openStorageBackedSession(metadata, db) {
+        const key = storageIdentity(metadata.path, metadata.id);
+        const storage = new SqliteStorage(db, { sessionId: metadata.id, now: this.now });
+        this.openStorages.set(key, storage);
+        const session = new StorageBackedSession(metadata, storage);
+        const openSession = new SqliteOpenSession(session, {
+            onClose: () => {
+                try {
+                    db.close();
                 }
-                lanes.push({ lane: "main", leafId: branchForkTargetId });
-                if (branchForkTargetId !== null) {
-                    const cached = readCachedBranch(db, source.id, branchForkTargetId);
-                    if (!cached) {
-                        throw new SessionError("invalid_fork_target", `Fork target is not on a cached branch: ${branchForkTargetId}`);
-                    }
-                    const rows = queryCachedBranchRows(db, source.id, cached, { order: "oldestFirst" });
-                    entries.push(...rows.map(entryRowFromCached));
-                    branchTips.push(branchForkTargetId);
+                finally {
+                    if (this.openStorages.get(key) === storage)
+                        this.openStorages.delete(key);
+                    this.openSessions.delete(openSession);
+                    this.pendingIds.delete(metadata.id);
                 }
-            }
-            const copiedIds = new Set(entries.map((entry) => entry.id));
-            const latestName = readLatestFact(db, source.id, "name", null);
-            const latestLabels = readLatestLabelFacts(db, source.id);
-            const labelsToCopy = latestLabels.filter((row) => options.scope === "tree" || (row.key !== null && copiedIds.has(row.key)));
-            const createdAt = Date.now();
-            const metadata = options.metadata ?? sourceMetadata.metadata;
-            let lease;
-            try {
-                lease = db.transaction(() => {
-                    insertSessionRow(db, {
-                        id,
-                        createdAt,
-                        cwd: options.cwd,
-                        parentSessionId: options.parentSessionId ?? source.id,
-                        metadata,
-                    });
-                    createSequence(db, id);
-                    createStats(db, id, entries.filter((entry) => entry.type === "message").length);
-                    let nextSeq = 1;
-                    const allocateSeq = () => nextSeq++;
-                    for (const entry of entries) {
-                        insertEntryRow(db, id, {
-                            seq: allocateSeq(),
-                            id: entry.id,
-                            parentId: entry.parent_id,
-                            type: entry.type,
-                            timestamp: entry.timestamp,
-                            payload: entry.payload,
-                        });
-                    }
-                    if (options.scope === "tree") {
-                        for (const lane of lanes)
-                            insertLane(db, id, allocateSeq(), lane.lane, lane.leafId);
-                    }
-                    else {
-                        createInitialLane(db, id, "main", branchForkTargetId);
-                    }
-                    if (latestName?.value !== undefined && latestName.value !== null) {
-                        appendFact(db, id, allocateSeq(), "name", null, latestName.value);
-                    }
-                    for (const label of labelsToCopy)
-                        appendFact(db, id, allocateSeq(), "label", label.key, label.value);
-                    setNextSequence(db, id, nextSeq);
-                    for (const tip of branchTips)
-                        buildCachedBranch(db, id, tip);
-                    return claimWriterLease(db, id, this.leaseOptions);
-                });
-            }
-            catch (error) {
-                if (error instanceof SessionError)
-                    throw error;
-                throw new SessionError("storage", `Failed to fork SQLite session ${id}`, error instanceof Error ? error : undefined);
-            }
-            const row = requireSessionRow(db, id);
-            return this.sessionFromLease(db, decodeSessionMetadata(row, path), lease);
+            },
         });
+        this.openSessions.add(openSession);
+        return openSession;
+    }
+    async repositoryPathForMetadata(metadata) {
+        const [expected, actual] = await Promise.all([
+            realpath(this.pathForSession(metadata.id)),
+            realpath(metadata.path),
+        ]);
+        if (expected !== actual) {
+            throw new Error(`SQLite session metadata path is outside this repository: ${metadata.path}`);
+        }
+        return actual;
     }
-    async close() {
-        await this.operations.drain();
-        for (const storage of [...this.activeStorages])
-            await storage.release();
-        if (this.database)
-            this.database.close();
-        this.database = undefined;
-        this.databasePromise = undefined;
-    }
-    async [Symbol.asyncDispose]() {
-        await this.close();
+    reserveId(id) {
+        if (this.pendingIds.has(id))
+            throw new Error(`Session is already open: ${id}`);
+        this.pendingIds.add(id);
     }
-    async getDatabasePath() {
-        this.databasePath ??= resultOrThrow(await this.options.env.absolutePath(this.options.databasePath), `Failed to resolve SQLite sessions database ${this.options.databasePath}`);
-        return this.databasePath;
+    pathForSession(id) {
+        return this.databasePath ?? sessionPath(this.directory, id);
     }
-    async getDatabase() {
-        if (!this.databasePromise)
-            this.databasePromise = this.openDatabase();
-        this.database = await this.databasePromise;
-        return this.database;
+    usesSharedDatabase() {
+        return this.databasePath !== undefined;
     }
-    async openDatabase() {
-        const path = await this.getDatabasePath();
-        resultOrThrow(await this.options.env.createDir(getParentPath(path), { recursive: true }), `Failed to create SQLite sessions directory ${path}`);
-        const db = await this.options.sqlite.open(path);
-        try {
-            configureSqliteDatabase(db);
-            await applyMigrations(db);
-            return db;
-        }
-        catch (error) {
-            db.close();
-            throw error;
-        }
+    assertOpen() {
+        if (this.closed)
+            throw new Error("SqliteSessionRepo is closed");
     }
 }
 //# sourceMappingURL=repo.js.map