lody 0.76.0 → 0.77.0

package/dist/turn-diff-store-worker.js

@@ -0,0 +1,1552 @@
+import { parentPort } from "node:worker_threads";
+import { createHash } from "node:crypto";
+import { mkdirSync, statSync } from "node:fs";
+import path__default from "node:path";
+import { performance } from "node:perf_hooks";
+import Database from "better-sqlite3";
+import * as zlib from "node:zlib";
+const DEFAULT_RETENTION_DAYS = 100;
+const DEFAULT_MAX_STORAGE_BYTES = 1024 ** 3;
+const DEFAULT_GC_TARGET_BYTES = 900 * 1024 ** 2;
+const REQUIRED_NODE_API_VERSION = 10;
+const SUPPORTED_SQLITE_ARCHS = ["x64", "arm64"];
+function describeUnsupportedTurnDiffSqliteRuntime(runtime) {
+  if (!SUPPORTED_SQLITE_ARCHS.includes(runtime.arch)) {
+    return `@lody/turn-diff-store does not support the ${runtime.arch} architecture: better-sqlite3 ships prebuilt binaries for ${SUPPORTED_SQLITE_ARCHS.join(" and ")} only.`;
+  }
+  const napi = Number.parseInt(runtime.napi ?? "", 10);
+  if (!Number.isFinite(napi) || napi < REQUIRED_NODE_API_VERSION) {
+    return `@lody/turn-diff-store needs Node-API ${REQUIRED_NODE_API_VERSION} (Node.js 22.14.0 or newer); received ${runtime.nodeVersion} with Node-API ${runtime.napi ?? "unknown"}.`;
+  }
+  return void 0;
+}
+function assertTurnDiffSqliteRuntimeSupported() {
+  const problem = describeUnsupportedTurnDiffSqliteRuntime({
+    napi: process.versions.napi,
+    arch: process.arch,
+    nodeVersion: process.version
+  });
+  if (problem) throw new Error(problem);
+}
+assertTurnDiffSqliteRuntimeSupported();
+const CODEC_RAW = 0;
+const CODEC_ZSTD = 1;
+const CODEC_GZIP = 2;
+const COMPRESSION_LEVEL = 1;
+const COMPRESSION_MIN_BYTES = 8 * 1024;
+const COMPRESSION_MIN_SAVINGS_BYTES = 64;
+const zstdCompressSync = zlib.zstdCompressSync;
+const zstdDecompressSync = zlib.zstdDecompressSync;
+const zstdCompressionLevelParameter = zlib.constants.ZSTD_c_compressionLevel;
+function compressChunk(bytes, preference) {
+  const raw = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.byteLength < COMPRESSION_MIN_BYTES) {
+    return { codec: CODEC_RAW, payload: raw };
+  }
+  let codec;
+  let compressed;
+  if (preference === "zstd" && zstdCompressSync !== void 0 && zstdCompressionLevelParameter !== void 0) {
+    compressed = zstdCompressSync(bytes, {
+      params: { [zstdCompressionLevelParameter]: COMPRESSION_LEVEL }
+    });
+    codec = CODEC_ZSTD;
+  } else {
+    compressed = zlib.gzipSync(bytes, { level: COMPRESSION_LEVEL });
+    codec = CODEC_GZIP;
+  }
+  return compressed.byteLength + COMPRESSION_MIN_SAVINGS_BYTES < raw.byteLength ? { codec, payload: compressed } : { codec: CODEC_RAW, payload: raw };
+}
+function decompressChunk(codec, payload) {
+  if (codec === CODEC_RAW) {
+    return Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength);
+  }
+  if (codec === CODEC_ZSTD) {
+    if (zstdDecompressSync === void 0) {
+      throw new Error("This Node.js runtime cannot decompress a stored zstd turn-diff chunk.");
+    }
+    return zstdDecompressSync(payload);
+  }
+  if (codec === CODEC_GZIP) {
+    return zlib.gunzipSync(payload);
+  }
+  throw new Error(`Unknown turn-diff chunk codec ${codec}.`);
+}
+const MASK_HEX = [
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0000000001804110",
+  "0000000001803110",
+  "0000000018035100",
+  "0000001800035300",
+  "0000019000353000",
+  "0000590003530000",
+  "0000d90003530000",
+  "0000d90103530000",
+  "0000d90303530000",
+  "0000d90313530000",
+  "0000d90f03530000",
+  "0000d90303537000",
+  "0000d90703537000",
+  "0000d90707537000",
+  "0000d91707537000",
+  "0000d91747537000",
+  "0000d91767537000",
+  "0000d93767537000",
+  "0000d93777537000",
+  "0000d93777577000",
+  "0000db3777577000"
+];
+const UINT32_BASE = 4294967296;
+function splitHex64(value) {
+  const padded = value.padStart(16, "0");
+  return {
+    hi: Number.parseInt(padded.slice(0, 8), 16) >>> 0,
+    lo: Number.parseInt(padded.slice(8), 16) >>> 0
+  };
+}
+function shiftLeftOne(hi, lo) {
+  return {
+    hi: (hi << 1 | lo >>> 31) >>> 0,
+    lo: lo << 1 >>> 0
+  };
+}
+function generateTables() {
+  const gearHi = new Uint32Array(256);
+  const gearLo = new Uint32Array(256);
+  const gearLsHi = new Uint32Array(256);
+  const gearLsLo = new Uint32Array(256);
+  for (let index = 0; index < 256; index += 1) {
+    const digest = createHash("md5").update(Buffer.alloc(64, index)).digest();
+    const hi = digest.readUInt32BE(0);
+    const lo = digest.readUInt32BE(4);
+    const shifted = shiftLeftOne(hi, lo);
+    gearHi[index] = hi;
+    gearLo[index] = lo;
+    gearLsHi[index] = shifted.hi;
+    gearLsLo[index] = shifted.lo;
+  }
+  return { gearHi, gearLo, gearLsHi, gearLsLo };
+}
+const TABLES = generateTables();
+function createConfig(minSize, avgSize, maxSize, normalization = 1) {
+  const bits = 31 - Math.clz32(avgSize);
+  const maskSHex = MASK_HEX[bits + normalization];
+  const maskLHex = MASK_HEX[bits - normalization];
+  if (maskSHex === void 0 || maskLHex === void 0) {
+    throw new Error(`FastCDC mask is unavailable for average size ${avgSize}.`);
+  }
+  const maskS = splitHex64(maskSHex);
+  const maskL = splitHex64(maskLHex);
+  const maskSLs = shiftLeftOne(maskS.hi, maskS.lo);
+  const maskLLs = shiftLeftOne(maskL.hi, maskL.lo);
+  return {
+    minSize,
+    avgSize,
+    maxSize,
+    maskSHi: maskS.hi,
+    maskSLo: maskS.lo,
+    maskLHi: maskL.hi,
+    maskLLo: maskL.lo,
+    maskSLsHi: maskSLs.hi,
+    maskSLsLo: maskSLs.lo,
+    maskLLsHi: maskLLs.hi,
+    maskLLsLo: maskLLs.lo
+  };
+}
+const DEFAULT_CONFIG = createConfig(8 * 1024, 32 * 1024, 128 * 1024, 1);
+function cutLength(bytes, start, available, config) {
+  let remaining = available;
+  if (remaining <= config.minSize) {
+    return remaining;
+  }
+  let center = config.avgSize;
+  if (remaining > config.maxSize) {
+    remaining = config.maxSize;
+  } else if (remaining < center) {
+    center = remaining;
+  }
+  let index = config.minSize >>> 1;
+  let hi = 0;
+  let lo = 0;
+  const centerHalf = center >>> 1;
+  const remainingHalf = remaining >>> 1;
+  const { gearHi, gearLo, gearLsHi, gearLsLo } = TABLES;
+  while (index < centerHalf) {
+    const relativeOffset = index << 1;
+    const first = bytes[start + relativeOffset];
+    const shiftedHi = (hi << 2 | lo >>> 30) >>> 0;
+    const shiftedLo = lo << 2 >>> 0;
+    const lowSum = shiftedLo + gearLsLo[first];
+    lo = lowSum >>> 0;
+    hi = shiftedHi + gearLsHi[first] + (lowSum >= UINT32_BASE ? 1 : 0) >>> 0;
+    if ((hi & config.maskSLsHi) === 0 && (lo & config.maskSLsLo) === 0) {
+      return relativeOffset;
+    }
+    const second = bytes[start + relativeOffset + 1];
+    const secondLowSum = lo + gearLo[second];
+    lo = secondLowSum >>> 0;
+    hi = hi + gearHi[second] + (secondLowSum >= UINT32_BASE ? 1 : 0) >>> 0;
+    if ((hi & config.maskSHi) === 0 && (lo & config.maskSLo) === 0) {
+      return relativeOffset + 1;
+    }
+    index += 1;
+  }
+  while (index < remainingHalf) {
+    const relativeOffset = index << 1;
+    const first = bytes[start + relativeOffset];
+    const shiftedHi = (hi << 2 | lo >>> 30) >>> 0;
+    const shiftedLo = lo << 2 >>> 0;
+    const lowSum = shiftedLo + gearLsLo[first];
+    lo = lowSum >>> 0;
+    hi = shiftedHi + gearLsHi[first] + (lowSum >= UINT32_BASE ? 1 : 0) >>> 0;
+    if ((hi & config.maskLLsHi) === 0 && (lo & config.maskLLsLo) === 0) {
+      return relativeOffset;
+    }
+    const second = bytes[start + relativeOffset + 1];
+    const secondLowSum = lo + gearLo[second];
+    lo = secondLowSum >>> 0;
+    hi = hi + gearHi[second] + (secondLowSum >= UINT32_BASE ? 1 : 0) >>> 0;
+    if ((hi & config.maskLHi) === 0 && (lo & config.maskLLo) === 0) {
+      return relativeOffset + 1;
+    }
+    index += 1;
+  }
+  return remaining;
+}
+function fastCdcV2020(bytes) {
+  const chunks = [];
+  let offset = 0;
+  while (offset < bytes.length) {
+    const length = cutLength(bytes, offset, bytes.length - offset, DEFAULT_CONFIG);
+    if (length <= 0) {
+      throw new Error(`FastCDC produced a zero-length chunk at byte ${offset}.`);
+    }
+    chunks.push({ offset, length });
+    offset += length;
+  }
+  return chunks;
+}
+const TURN_DIFF_APPLICATION_ID = 1280590897;
+const SCHEMA_VERSION = 2;
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const MIN_RETENTION_DAYS = 1;
+const MAX_RETENTION_DAYS = 365;
+const GC_TURN_BATCH_SIZE = 128;
+const GC_VACUUM_PAGE_BATCH_SIZE = 1024;
+const LEGACY_TABLE_NAMES = ["diff_docs", "diff_doc_updates", "diff_events"];
+const STORE_TABLE_NAMES = [
+  "store_counters",
+  "turns",
+  "chunks",
+  "snapshots",
+  "snapshot_chunks",
+  "turn_files",
+  "path_heads"
+];
+const LEGACY_INDEX_NAMES = [
+  "diff_events_owner_path_expires_idx",
+  "diff_events_owner_expires_idx",
+  "diff_doc_updates_doc_created_idx"
+];
+const STORE_INDEX_NAMES = [
+  "turns_owner_expiry_idx",
+  "turns_evicted_order_idx",
+  "turn_files_path_idx",
+  "turn_files_old_snapshot_idx",
+  "turn_files_new_snapshot_idx",
+  "snapshot_chunks_hash_idx",
+  "path_heads_snapshot_idx",
+  "path_heads_source_turn_idx"
+];
+const KNOWN_SCHEMA_OBJECT_NAMES = /* @__PURE__ */ new Set([
+  ...LEGACY_TABLE_NAMES,
+  ...LEGACY_INDEX_NAMES,
+  ...STORE_TABLE_NAMES,
+  ...STORE_INDEX_NAMES
+]);
+const LEGACY_SCHEMA_SQL = `
+  CREATE TABLE diff_docs (
+    doc_id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL,
+    owner_session_id TEXT NOT NULL,
+    path TEXT NOT NULL,
+    created_at_ms INTEGER NOT NULL,
+    updated_at_ms INTEGER NOT NULL,
+    snapshot BLOB,
+    snapshot_frontiers_json TEXT,
+    snapshot_at_ms INTEGER,
+    UNIQUE(workspace_id, owner_session_id, path)
+  );
+
+  CREATE TABLE diff_doc_updates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    doc_id TEXT NOT NULL,
+    update_bytes BLOB NOT NULL,
+    frontiers_json TEXT NOT NULL,
+    created_at_ms INTEGER NOT NULL,
+    FOREIGN KEY(doc_id) REFERENCES diff_docs(doc_id) ON DELETE CASCADE
+  );
+
+  CREATE TABLE diff_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    workspace_id TEXT NOT NULL,
+    owner_session_id TEXT NOT NULL,
+    turn_id TEXT NOT NULL,
+    path TEXT NOT NULL,
+    doc_id TEXT NOT NULL,
+    old_frontiers_json TEXT NOT NULL,
+    new_frontiers_json TEXT NOT NULL,
+    old_present INTEGER NOT NULL,
+    new_present INTEGER NOT NULL,
+    add_count INTEGER,
+    del_count INTEGER,
+    source TEXT NOT NULL,
+    captured_at_ms INTEGER NOT NULL,
+    expires_at_ms INTEGER NOT NULL,
+    UNIQUE(workspace_id, owner_session_id, turn_id, path),
+    FOREIGN KEY(doc_id) REFERENCES diff_docs(doc_id) ON DELETE CASCADE
+  );
+
+  CREATE INDEX diff_events_owner_path_expires_idx
+    ON diff_events(workspace_id, owner_session_id, path, expires_at_ms, captured_at_ms, id);
+  CREATE INDEX diff_events_owner_expires_idx
+    ON diff_events(workspace_id, owner_session_id, expires_at_ms, path);
+  CREATE INDEX diff_doc_updates_doc_created_idx
+    ON diff_doc_updates(doc_id, created_at_ms, id);
+`;
+const CURRENT_SCHEMA_SQL = `
+  CREATE TABLE store_counters (
+    name TEXT PRIMARY KEY,
+    value INTEGER NOT NULL CHECK(value >= 0)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE turns (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    owner_id TEXT NOT NULL,
+    turn_key TEXT NOT NULL,
+    order_key TEXT NOT NULL,
+    captured_at_ms INTEGER NOT NULL,
+    expires_at_ms INTEGER NOT NULL,
+    evicted INTEGER NOT NULL DEFAULT 0 CHECK(evicted IN (0, 1)),
+    UNIQUE(owner_id, turn_key),
+    UNIQUE(owner_id, order_key)
+  );
+
+  CREATE TABLE chunks (
+    hash BLOB PRIMARY KEY CHECK(length(hash) = 32),
+    codec INTEGER NOT NULL CHECK(codec IN (0, 1, 2)),
+    raw_size INTEGER NOT NULL CHECK(raw_size >= 0),
+    payload BLOB NOT NULL,
+    ref_count INTEGER NOT NULL DEFAULT 0 CHECK(ref_count >= 0)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE snapshots (
+    id INTEGER PRIMARY KEY,
+    content_hash BLOB NOT NULL UNIQUE CHECK(length(content_hash) = 32),
+    raw_size INTEGER NOT NULL CHECK(raw_size >= 0),
+    ref_count INTEGER NOT NULL DEFAULT 0 CHECK(ref_count >= 0)
+  );
+
+  CREATE TABLE snapshot_chunks (
+    snapshot_id INTEGER NOT NULL REFERENCES snapshots(id) ON DELETE CASCADE,
+    ordinal INTEGER NOT NULL,
+    chunk_hash BLOB NOT NULL REFERENCES chunks(hash),
+    raw_size INTEGER NOT NULL CHECK(raw_size >= 0),
+    PRIMARY KEY(snapshot_id, ordinal)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE turn_files (
+    id INTEGER PRIMARY KEY,
+    turn_id INTEGER NOT NULL REFERENCES turns(id) ON DELETE CASCADE,
+    path TEXT NOT NULL,
+    old_snapshot_id INTEGER REFERENCES snapshots(id),
+    new_snapshot_id INTEGER REFERENCES snapshots(id),
+    add_count INTEGER NOT NULL CHECK(add_count >= 0),
+    del_count INTEGER NOT NULL CHECK(del_count >= 0),
+    UNIQUE(turn_id, path)
+  );
+
+  CREATE TABLE path_heads (
+    owner_id TEXT NOT NULL,
+    path TEXT NOT NULL,
+    snapshot_id INTEGER REFERENCES snapshots(id),
+    source_turn_id INTEGER NOT NULL,
+    updated_order_key TEXT NOT NULL,
+    head_proof INTEGER NOT NULL CHECK(head_proof > 0),
+    PRIMARY KEY(owner_id, path)
+  ) WITHOUT ROWID;
+
+  CREATE INDEX turns_owner_expiry_idx
+    ON turns(owner_id, evicted, expires_at_ms, order_key, id);
+  CREATE INDEX turns_evicted_order_idx
+    ON turns(evicted, order_key, id);
+  CREATE INDEX turn_files_path_idx
+    ON turn_files(path, turn_id);
+  CREATE INDEX turn_files_old_snapshot_idx
+    ON turn_files(old_snapshot_id) WHERE old_snapshot_id IS NOT NULL;
+  CREATE INDEX turn_files_new_snapshot_idx
+    ON turn_files(new_snapshot_id) WHERE new_snapshot_id IS NOT NULL;
+  CREATE INDEX snapshot_chunks_hash_idx
+    ON snapshot_chunks(chunk_hash);
+  CREATE INDEX path_heads_snapshot_idx
+    ON path_heads(snapshot_id) WHERE snapshot_id IS NOT NULL;
+  CREATE INDEX path_heads_source_turn_idx
+    ON path_heads(source_turn_id);
+`;
+class SqliteTurnDiffStore {
+  db;
+  options;
+  closed = false;
+  constructor(options) {
+    this.options = normalizeOptions(options);
+    mkdirSync(path__default.dirname(this.options.dbPath), { recursive: true });
+    this.db = new Database(this.options.dbPath, { timeout: 5e3 });
+    try {
+      this.initializeSchema();
+    } catch (error) {
+      this.db.close();
+      throw error;
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.db.close();
+  }
+  allocateHeadProof() {
+    this.assertOpen();
+    const allocate = this.db.transaction(() => {
+      const row = this.db.prepare(
+        `
+            UPDATE store_counters
+            SET value = value + 1
+            WHERE name = 'head_proof'
+            RETURNING value AS id
+          `
+      ).get();
+      if (!row || !Number.isSafeInteger(row.id) || row.id <= 0) {
+        throw new Error("Failed to allocate a turn-diff head proof token.");
+      }
+      return row.id;
+    });
+    return allocate.immediate();
+  }
+  recordTurn(input) {
+    this.assertOpen();
+    validateRecordInput(input);
+    const startedAt = performance.now();
+    const recordedAtMs = input.recordedAtMs;
+    const capturedAtMs = input.capturedAtMs;
+    const orderKey = input.orderKey ?? defaultTurnOrderKey(capturedAtMs, input.turnId);
+    const expiresAtMs = capturedAtMs + this.options.retentionDays * DAY_MS;
+    const metrics = {
+      rawBytes: 0,
+      newChunks: 0,
+      reusedChunks: 0,
+      encodeMs: 0,
+      chunkingMs: 0,
+      hashingMs: 0,
+      compressionMs: 0
+    };
+    const existingTurn = this.db.prepare(
+      `
+          SELECT id, captured_at_ms, order_key, expires_at_ms, evicted
+          FROM turns
+          WHERE owner_id = ? AND turn_key = ?
+        `
+    ).get(input.ownerId, input.turnId);
+    if (existingTurn !== void 0 && (existingTurn.evicted !== 0 || existingTurn.expires_at_ms <= recordedAtMs) || existingTurn === void 0 && expiresAtMs <= recordedAtMs) {
+      return {
+        files: [],
+        metrics: {
+          ...metrics,
+          transactionMs: 0,
+          totalMs: performance.now() - startedAt
+        },
+        gcScheduled: existingTurn !== void 0 && existingTurn.expires_at_ms <= recordedAtMs || this.shouldRunGc(recordedAtMs)
+      };
+    }
+    const existingPaths = new Set(
+      existingTurn === void 0 ? [] : this.db.prepare("SELECT path FROM turn_files WHERE turn_id = ?").all(existingTurn.id).map((row) => row.path)
+    );
+    const pendingEvents = input.events.filter((event) => !existingPaths.has(event.path));
+    if (pendingEvents.length === 0) {
+      const files2 = existingTurn ? this.listTurnFiles({
+        ownerId: input.ownerId,
+        turnId: input.turnId,
+        nowMs: recordedAtMs
+      }) : [];
+      return {
+        files: files2,
+        metrics: {
+          ...metrics,
+          transactionMs: 0,
+          totalMs: performance.now() - startedAt
+        },
+        gcScheduled: this.shouldRunGc(recordedAtMs)
+      };
+    }
+    const snapshotCache = /* @__PURE__ */ new Map();
+    const chunkCache = /* @__PURE__ */ new Map();
+    const preparedEvents = pendingEvents.map((event) => ({
+      path: event.path,
+      oldSnapshot: this.prepareSnapshot(event.oldText, snapshotCache, chunkCache, metrics),
+      newSnapshot: this.prepareSnapshot(event.newText, snapshotCache, chunkCache, metrics),
+      newIsCurrent: event.newIsCurrent,
+      headProof: event.headProof,
+      add: event.add,
+      del: event.del
+    }));
+    const transactionStartedAt = performance.now();
+    const commit = this.db.transaction(() => {
+      const turn = this.getOrCreateTurn(
+        input.ownerId,
+        input.turnId,
+        orderKey,
+        capturedAtMs,
+        expiresAtMs
+      );
+      if (turn.evicted !== 0 || turn.expires_at_ms <= recordedAtMs) {
+        return false;
+      }
+      const materializedSnapshots = /* @__PURE__ */ new Map();
+      const releasedSnapshotIds = /* @__PURE__ */ new Set();
+      for (const event of preparedEvents) {
+        const existing = this.db.prepare("SELECT id FROM turn_files WHERE turn_id = ? AND path = ?").get(turn.id, event.path);
+        if (existing) continue;
+        const oldSnapshotId = this.materializeSnapshot(event.oldSnapshot, materializedSnapshots);
+        const newSnapshotId = this.materializeSnapshot(event.newSnapshot, materializedSnapshots);
+        this.db.prepare(
+          `
+              INSERT INTO turn_files (
+                turn_id, path, old_snapshot_id, new_snapshot_id, add_count, del_count
+              ) VALUES (?, ?, ?, ?, ?, ?)
+            `
+        ).run(turn.id, event.path, oldSnapshotId, newSnapshotId, event.add, event.del);
+        this.changeSnapshotRefCount(oldSnapshotId, 1);
+        this.changeSnapshotRefCount(newSnapshotId, 1);
+        if (event.newIsCurrent) {
+          if (event.headProof === null) {
+            throw new Error(`Missing head proof for current turn-diff path ${event.path}.`);
+          }
+          const releasedSnapshotId = this.updatePathHead(
+            input.ownerId,
+            event.path,
+            newSnapshotId,
+            turn.id,
+            turn.order_key,
+            event.headProof
+          );
+          if (releasedSnapshotId !== void 0) {
+            releasedSnapshotIds.add(releasedSnapshotId);
+          }
+        }
+      }
+      this.deleteUnreferencedSnapshotsAndChunks(releasedSnapshotIds);
+      return true;
+    });
+    commit.immediate();
+    const transactionMs = performance.now() - transactionStartedAt;
+    const files = this.listTurnFiles({
+      ownerId: input.ownerId,
+      turnId: input.turnId,
+      nowMs: recordedAtMs
+    });
+    const gcScheduled = this.shouldRunGc(recordedAtMs);
+    return {
+      files,
+      metrics: {
+        ...metrics,
+        transactionMs,
+        totalMs: performance.now() - startedAt
+      },
+      gcScheduled
+    };
+  }
+  listChangedPaths(input) {
+    this.assertOpen();
+    const rows = this.db.prepare(
+      `
+          SELECT DISTINCT tf.path
+          FROM turn_files AS tf
+          JOIN turns AS t ON t.id = tf.turn_id
+          WHERE t.owner_id = ? AND t.evicted = 0 AND t.expires_at_ms > ?
+          ORDER BY tf.path ASC
+        `
+    ).all(input.ownerId, input.nowMs);
+    return rows.map((row) => row.path);
+  }
+  getEarliestOldSnapshot(input) {
+    this.assertOpen();
+    assertSnapshotReadLimit(input.maxRawBytes);
+    return this.db.transaction(() => {
+      const row = this.db.prepare(
+        `
+            SELECT tf.old_snapshot_id AS snapshot_id, COALESCE(s.raw_size, 0) AS raw_size
+            FROM turn_files AS tf
+            JOIN turns AS t ON t.id = tf.turn_id
+            LEFT JOIN snapshots AS s ON s.id = tf.old_snapshot_id
+            WHERE t.owner_id = ? AND t.evicted = 0 AND tf.path = ? AND t.expires_at_ms > ?
+            ORDER BY t.order_key ASC, t.id ASC
+            LIMIT 1
+          `
+      ).get(input.ownerId, input.path, input.nowMs);
+      if (!row) return { status: "unavailable" };
+      if (exceedsSnapshotReadLimit(row.raw_size, input.maxRawBytes)) {
+        return { status: "too_large", rawBytes: row.raw_size };
+      }
+      return { status: "ready", text: this.readSnapshotText(row.snapshot_id) };
+    })();
+  }
+  getTurnSnapshot(input) {
+    this.assertOpen();
+    assertSnapshotReadLimit(input.maxRawBytes);
+    return this.db.transaction(() => {
+      const row = this.db.prepare(
+        `
+            SELECT
+              tf.old_snapshot_id,
+              tf.new_snapshot_id,
+              COALESCE(old_snapshot.raw_size, 0) AS old_raw_size,
+              COALESCE(new_snapshot.raw_size, 0) AS new_raw_size
+            FROM turn_files AS tf
+            JOIN turns AS t ON t.id = tf.turn_id
+            LEFT JOIN snapshots AS old_snapshot ON old_snapshot.id = tf.old_snapshot_id
+            LEFT JOIN snapshots AS new_snapshot ON new_snapshot.id = tf.new_snapshot_id
+            WHERE t.owner_id = ?
+              AND t.turn_key = ?
+              AND t.evicted = 0
+              AND tf.path = ?
+              AND t.expires_at_ms > ?
+            LIMIT 1
+          `
+      ).get(input.ownerId, input.turnId, input.path, input.nowMs);
+      if (!row) return { status: "unavailable" };
+      const rawBytes = row.old_raw_size + row.new_raw_size;
+      if (exceedsSnapshotReadLimit(rawBytes, input.maxRawBytes)) {
+        return { status: "too_large", rawBytes };
+      }
+      return {
+        status: "ready",
+        oldText: this.readSnapshotText(row.old_snapshot_id),
+        newText: this.readSnapshotText(row.new_snapshot_id)
+      };
+    })();
+  }
+  getLatestText(input) {
+    this.assertOpen();
+    assertSnapshotReadLimit(input.maxRawBytes);
+    return this.db.transaction(() => {
+      const row = this.db.prepare(
+        `
+            SELECT ph.snapshot_id, COALESCE(s.raw_size, 0) AS raw_size
+            FROM path_heads AS ph
+            LEFT JOIN snapshots AS s ON s.id = ph.snapshot_id
+            WHERE ph.owner_id = ? AND ph.path = ?
+          `
+      ).get(input.ownerId, input.path);
+      if (!row) return { status: "untracked" };
+      if (exceedsSnapshotReadLimit(row.raw_size, input.maxRawBytes)) {
+        return { status: "too_large", rawBytes: row.raw_size };
+      }
+      return { status: "tracked", text: this.readSnapshotText(row.snapshot_id) };
+    })();
+  }
+  listTurnFiles(input) {
+    this.assertOpen();
+    const rows = this.db.prepare(
+      `
+          SELECT tf.path, tf.add_count, tf.del_count
+          FROM turn_files AS tf
+          JOIN turns AS t ON t.id = tf.turn_id
+          WHERE t.owner_id = ?
+            AND t.turn_key = ?
+            AND t.evicted = 0
+            AND t.expires_at_ms > ?
+          ORDER BY tf.path ASC
+        `
+    ).all(input.ownerId, input.turnId, input.nowMs);
+    return rows.map((row) => ({ path: row.path, add: row.add_count, del: row.del_count }));
+  }
+  shouldRunGc(nowMs) {
+    this.assertOpen();
+    const expired = this.db.prepare("SELECT 1 AS id FROM turns WHERE expires_at_ms <= ? LIMIT 1").get(nowMs);
+    return expired !== void 0 || this.storageBytes().total > this.options.maxStorageBytes;
+  }
+  gc(nowMs) {
+    const cursor = this.beginGc(nowMs);
+    while (true) {
+      const result = this.gcStep(cursor);
+      if (result !== null) return result;
+    }
+  }
+  beginGc(nowMs) {
+    this.assertOpen();
+    const before = this.storageBytes(true);
+    return {
+      nowMs,
+      before,
+      sizeGcTriggered: before.total > this.options.maxStorageBytes,
+      phase: "expired",
+      deletedTurns: 0,
+      deletedSnapshots: 0,
+      deletedChunks: 0
+    };
+  }
+  gcStep(cursor) {
+    this.assertOpen();
+    if (cursor.phase === "expired") {
+      const expiredIds = this.db.prepare("SELECT id FROM turns WHERE expires_at_ms <= ? ORDER BY id ASC LIMIT ?").all(cursor.nowMs, GC_TURN_BATCH_SIZE).map((row) => row.id);
+      if (expiredIds.length === 0) {
+        cursor.phase = cursor.sizeGcTriggered ? "turns" : "vacuum";
+        return null;
+      }
+      this.accumulateDeletedTurns(cursor, expiredIds, "delete");
+      return null;
+    }
+    if (cursor.phase === "turns") {
+      if (this.estimatedCompactedStorageBytes() <= this.options.gcTargetBytes) {
+        cursor.phase = "vacuum";
+        return null;
+      }
+      const oldestIds = this.db.prepare(
+        `
+              SELECT id
+              FROM turns
+              WHERE evicted = 0
+                AND id != (
+                SELECT id
+                FROM turns
+                WHERE evicted = 0
+                ORDER BY order_key DESC, id DESC
+                LIMIT 1
+              )
+              ORDER BY order_key ASC, id ASC
+              LIMIT ?
+            `
+      ).all(GC_TURN_BATCH_SIZE).map((row) => row.id);
+      if (oldestIds.length === 0) {
+        cursor.phase = "heads";
+        return null;
+      }
+      this.accumulateDeletedTurns(cursor, oldestIds, "evict");
+      return null;
+    }
+    if (cursor.phase === "heads") {
+      if (this.estimatedCompactedStorageBytes() <= this.options.gcTargetBytes) {
+        cursor.phase = "vacuum";
+        return null;
+      }
+      const oldestHeads = this.db.prepare(
+        `
+            SELECT owner_id, path, snapshot_id, source_turn_id, head_proof
+            FROM path_heads
+            WHERE source_turn_id IS NOT (
+              SELECT id
+              FROM turns
+              WHERE evicted = 0
+              ORDER BY order_key DESC, id DESC
+              LIMIT 1
+            )
+            ORDER BY head_proof ASC, source_turn_id ASC, owner_id ASC, path ASC
+            LIMIT ?
+          `
+      ).all(GC_TURN_BATCH_SIZE);
+      if (oldestHeads.length === 0) {
+        cursor.phase = "vacuum";
+        return null;
+      }
+      const deleted = this.deletePathHeads(oldestHeads);
+      cursor.deletedSnapshots += deleted.snapshots;
+      cursor.deletedChunks += deleted.chunks;
+      return null;
+    }
+    if (cursor.phase === "vacuum") {
+      const freePages = this.db.pragma("freelist_count", { simple: true });
+      if (freePages === 0) {
+        cursor.phase = "checkpoint";
+        return null;
+      }
+      this.db.pragma(`incremental_vacuum(${Math.min(freePages, GC_VACUUM_PAGE_BATCH_SIZE)})`);
+      return null;
+    }
+    if (cursor.phase === "checkpoint") {
+      const after = this.storageBytes(true);
+      cursor.phase = "done";
+      return {
+        deletedTurns: cursor.deletedTurns,
+        deletedSnapshots: cursor.deletedSnapshots,
+        deletedChunks: cursor.deletedChunks,
+        before: cursor.before,
+        after,
+        blockedByLiveData: cursor.sizeGcTriggered && after.total > this.options.gcTargetBytes
+      };
+    }
+    throw new Error("Turn-diff GC cursor has already completed.");
+  }
+  stats() {
+    this.assertOpen();
+    const row = this.db.prepare(
+      `
+          SELECT
+            (SELECT COUNT(*) FROM turns WHERE evicted = 0) AS turns,
+            (SELECT COUNT(*) FROM turn_files) AS files,
+            (SELECT COUNT(*) FROM snapshots) AS snapshots,
+            (SELECT COUNT(*) FROM chunks) AS chunks,
+            (SELECT COALESCE(SUM(ref_count), 0) FROM snapshots) AS snapshot_references,
+            (SELECT COALESCE(SUM(ref_count), 0) FROM chunks) AS chunk_references,
+            (SELECT COALESCE(SUM(raw_size), 0) FROM chunks) AS raw_chunk_bytes,
+            (SELECT COALESCE(SUM(length(payload)), 0) FROM chunks) AS stored_chunk_bytes,
+            (
+              SELECT COUNT(*)
+              FROM snapshots AS s
+              WHERE s.ref_count != (
+                (SELECT COUNT(*) FROM turn_files WHERE old_snapshot_id = s.id) +
+                (SELECT COUNT(*) FROM turn_files WHERE new_snapshot_id = s.id) +
+                (SELECT COUNT(*) FROM path_heads WHERE snapshot_id = s.id)
+              )
+            ) AS invalid_snapshot_ref_counts,
+            (
+              SELECT COUNT(*)
+              FROM chunks AS c
+              WHERE c.ref_count != (
+                SELECT COUNT(*) FROM snapshot_chunks WHERE chunk_hash = c.hash
+              )
+            ) AS invalid_chunk_ref_counts
+        `
+    ).get();
+    const integrity = this.db.prepare("PRAGMA integrity_check").get();
+    return {
+      turns: row.turns,
+      files: row.files,
+      snapshots: row.snapshots,
+      chunks: row.chunks,
+      snapshotReferences: row.snapshot_references,
+      chunkReferences: row.chunk_references,
+      rawChunkBytes: row.raw_chunk_bytes,
+      storedChunkBytes: row.stored_chunk_bytes,
+      invalidSnapshotRefCounts: row.invalid_snapshot_ref_counts,
+      invalidChunkRefCounts: row.invalid_chunk_ref_counts,
+      integrity: integrity.integrity_check,
+      storage: this.storageBytes()
+    };
+  }
+  initializeSchema() {
+    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("foreign_keys = OFF");
+    const initialize = this.db.transaction(() => {
+      const version = this.db.pragma("user_version", { simple: true });
+      const applicationId = this.db.pragma("application_id", { simple: true });
+      const schemaObjects = readSchemaObjects(this.db);
+      const fingerprint = schemaFingerprint(schemaObjects);
+      const objectNames = new Set(schemaObjects.map((row) => row.name));
+      const isFreshDatabase = applicationId === 0 && version === 0 && schemaObjects.length === 0;
+      const isLegacyDatabase = applicationId === 0 && version === 0 && fingerprint === expectedSchemaFingerprint(LEGACY_SCHEMA_SQL);
+      const isOwnedDatabase = applicationId === TURN_DIFF_APPLICATION_ID;
+      if (!isFreshDatabase && !isLegacyDatabase && !isOwnedDatabase) {
+        throw this.unknownSchemaError();
+      }
+      if (isOwnedDatabase) {
+        const unknownObjects = [...objectNames].filter(
+          (name) => !KNOWN_SCHEMA_OBJECT_NAMES.has(name)
+        );
+        if (unknownObjects.length > 0) throw this.unknownSchemaError();
+        if (version < 0 || version > SCHEMA_VERSION) {
+          throw new Error(`Unsupported turn-diff store schema version ${version}.`);
+        }
+      }
+      const hasCurrentSchema = isOwnedDatabase && version === SCHEMA_VERSION && fingerprint === expectedSchemaFingerprint(CURRENT_SCHEMA_SQL);
+      if (!hasCurrentSchema) {
+        this.dropKnownSchema();
+        this.createSchema();
+      }
+      this.db.prepare("INSERT OR IGNORE INTO store_counters(name, value) VALUES ('head_proof', 0)").run();
+      this.db.pragma(`application_id = ${TURN_DIFF_APPLICATION_ID}`);
+      this.db.pragma(`user_version = ${SCHEMA_VERSION}`);
+    });
+    initialize.immediate();
+    const autoVacuum = this.db.pragma("auto_vacuum", { simple: true });
+    if (autoVacuum !== 2) {
+      this.db.pragma("auto_vacuum = INCREMENTAL");
+      this.db.exec("VACUUM");
+    }
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = FULL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("wal_autocheckpoint = 1000");
+  }
+  unknownSchemaError() {
+    return new Error(
+      `Turn-diff store ${this.options.dbPath} has an unknown SQLite schema and was not modified.`
+    );
+  }
+  dropKnownSchema() {
+    this.db.exec(`
+      DROP TABLE IF EXISTS path_heads;
+      DROP TABLE IF EXISTS turn_files;
+      DROP TABLE IF EXISTS snapshot_chunks;
+      DROP TABLE IF EXISTS snapshots;
+      DROP TABLE IF EXISTS chunks;
+      DROP TABLE IF EXISTS turns;
+      DROP TABLE IF EXISTS store_counters;
+      DROP TABLE IF EXISTS diff_events;
+      DROP TABLE IF EXISTS diff_doc_updates;
+      DROP TABLE IF EXISTS diff_docs;
+    `);
+  }
+  createSchema() {
+    this.db.exec(CURRENT_SCHEMA_SQL);
+  }
+  getOrCreateTurn(ownerId, turnKey, orderKey, capturedAtMs, expiresAtMs) {
+    this.db.prepare(
+      `
+          INSERT INTO turns(owner_id, turn_key, order_key, captured_at_ms, expires_at_ms)
+          VALUES (?, ?, ?, ?, ?)
+          ON CONFLICT(owner_id, turn_key) DO NOTHING
+        `
+    ).run(ownerId, turnKey, orderKey, capturedAtMs, expiresAtMs);
+    const row = this.db.prepare(
+      `
+          SELECT id, captured_at_ms, order_key, expires_at_ms, evicted
+          FROM turns
+          WHERE owner_id = ? AND turn_key = ?
+        `
+    ).get(ownerId, turnKey);
+    if (!row) throw new Error(`Failed to create turn-diff turn ${turnKey}.`);
+    return row;
+  }
+  prepareSnapshot(text, snapshotCache, chunkCache, metrics) {
+    if (text === null) return null;
+    const encodeStartedAt = performance.now();
+    const bytes = Buffer.from(text, "utf8");
+    metrics.encodeMs += performance.now() - encodeStartedAt;
+    metrics.rawBytes += bytes.byteLength;
+    const fullHashStartedAt = performance.now();
+    const contentHash = createHash("sha256").update(bytes).digest();
+    metrics.hashingMs += performance.now() - fullHashStartedAt;
+    const hashKey = contentHash.toString("hex");
+    const cached = snapshotCache.get(hashKey);
+    if (cached) return cached;
+    const existing = this.db.prepare("SELECT id, raw_size FROM snapshots WHERE content_hash = ?").get(contentHash);
+    if (existing) {
+      if (existing.raw_size !== bytes.byteLength) {
+        throw new Error("SHA-256 snapshot collision detected while storing turn diff.");
+      }
+      const count = this.db.prepare("SELECT COUNT(*) AS count FROM snapshot_chunks WHERE snapshot_id = ?").get(existing.id);
+      metrics.reusedChunks += count.count;
+      const prepared2 = {
+        contentHash,
+        hashKey,
+        rawSize: bytes.byteLength,
+        existingId: existing.id,
+        chunks: []
+      };
+      snapshotCache.set(hashKey, prepared2);
+      return prepared2;
+    }
+    const chunkingStartedAt = performance.now();
+    const boundaries = fastCdcV2020(bytes);
+    metrics.chunkingMs += performance.now() - chunkingStartedAt;
+    const chunks = [];
+    for (const boundary of boundaries) {
+      const view = bytes.subarray(boundary.offset, boundary.offset + boundary.length);
+      const hashStartedAt = performance.now();
+      const hash = createHash("sha256").update(view).digest();
+      metrics.hashingMs += performance.now() - hashStartedAt;
+      const chunkHashKey = hash.toString("hex");
+      const requestCached = chunkCache.get(chunkHashKey);
+      if (requestCached) {
+        if (requestCached.rawSize !== view.byteLength) {
+          throw new Error("SHA-256 chunk collision detected within a turn-diff request.");
+        }
+        metrics.reusedChunks += 1;
+        chunks.push(requestCached);
+        continue;
+      }
+      const stored = this.db.prepare("SELECT raw_size FROM chunks WHERE hash = ?").get(hash);
+      if (stored) {
+        if (stored.raw_size !== view.byteLength) {
+          throw new Error("SHA-256 chunk collision detected while storing turn diff.");
+        }
+        const prepared3 = {
+          hash,
+          hashKey: chunkHashKey,
+          rawSize: view.byteLength,
+          codec: null,
+          payload: null
+        };
+        metrics.reusedChunks += 1;
+        chunkCache.set(chunkHashKey, prepared3);
+        chunks.push(prepared3);
+        continue;
+      }
+      const compressionStartedAt = performance.now();
+      const encoded = compressChunk(view, this.options.compression);
+      metrics.compressionMs += performance.now() - compressionStartedAt;
+      const prepared2 = {
+        hash,
+        hashKey: chunkHashKey,
+        rawSize: view.byteLength,
+        codec: encoded.codec,
+        payload: encoded.payload
+      };
+      metrics.newChunks += 1;
+      chunkCache.set(chunkHashKey, prepared2);
+      chunks.push(prepared2);
+    }
+    const prepared = {
+      contentHash,
+      hashKey,
+      rawSize: bytes.byteLength,
+      existingId: null,
+      chunks
+    };
+    snapshotCache.set(hashKey, prepared);
+    return prepared;
+  }
+  materializeSnapshot(snapshot, materialized) {
+    if (snapshot === null) return null;
+    const cachedId = materialized.get(snapshot.hashKey);
+    if (cachedId !== void 0) return cachedId;
+    if (snapshot.existingId !== null) {
+      materialized.set(snapshot.hashKey, snapshot.existingId);
+      return snapshot.existingId;
+    }
+    const existing = this.db.prepare("SELECT id, raw_size FROM snapshots WHERE content_hash = ?").get(snapshot.contentHash);
+    if (existing) {
+      if (existing.raw_size !== snapshot.rawSize) {
+        throw new Error("SHA-256 snapshot collision detected during turn-diff commit.");
+      }
+      materialized.set(snapshot.hashKey, existing.id);
+      return existing.id;
+    }
+    const insert = this.db.prepare("INSERT INTO snapshots(content_hash, raw_size, ref_count) VALUES (?, ?, 0)").run(snapshot.contentHash, snapshot.rawSize);
+    const snapshotId = Number(insert.lastInsertRowid);
+    for (let ordinal = 0; ordinal < snapshot.chunks.length; ordinal += 1) {
+      const chunk = snapshot.chunks[ordinal];
+      if (!chunk) throw new Error(`Missing prepared chunk ${ordinal}.`);
+      if (chunk.payload !== null && chunk.codec !== null) {
+        this.db.prepare(
+          `
+              INSERT INTO chunks(hash, codec, raw_size, payload, ref_count)
+              VALUES (?, ?, ?, ?, 0)
+              ON CONFLICT(hash) DO NOTHING
+            `
+        ).run(chunk.hash, chunk.codec, chunk.rawSize, chunk.payload);
+      }
+      this.db.prepare(
+        `
+            INSERT INTO snapshot_chunks(snapshot_id, ordinal, chunk_hash, raw_size)
+            VALUES (?, ?, ?, ?)
+          `
+      ).run(snapshotId, ordinal, chunk.hash, chunk.rawSize);
+      const updated = this.db.prepare("UPDATE chunks SET ref_count = ref_count + 1 WHERE hash = ?").run(chunk.hash);
+      if (updated.changes !== 1) {
+        throw new Error(`Failed to reference turn-diff chunk ${chunk.hashKey}.`);
+      }
+    }
+    materialized.set(snapshot.hashKey, snapshotId);
+    return snapshotId;
+  }
+  updatePathHead(ownerId, workspacePath, newSnapshotId, sourceTurnId, orderKey, headProof) {
+    const previous = this.db.prepare(
+      `
+          SELECT snapshot_id, source_turn_id, updated_order_key, head_proof
+          FROM path_heads
+          WHERE owner_id = ? AND path = ?
+        `
+    ).get(ownerId, workspacePath);
+    if (previous !== void 0 && headProof <= previous.head_proof) return void 0;
+    const preserveNewerSource = previous !== void 0 && previous.snapshot_id === newSnapshotId && previous.updated_order_key > orderKey;
+    const nextSourceTurnId = preserveNewerSource ? previous.source_turn_id : sourceTurnId;
+    const nextOrderKey = preserveNewerSource ? previous.updated_order_key : orderKey;
+    const releasedSnapshotId = previous?.snapshot_id !== newSnapshotId ? previous?.snapshot_id ?? void 0 : void 0;
+    if (previous?.snapshot_id !== newSnapshotId) {
+      this.changeSnapshotRefCount(previous?.snapshot_id ?? null, -1);
+      this.changeSnapshotRefCount(newSnapshotId, 1);
+    }
+    this.db.prepare(
+      `
+          INSERT INTO path_heads(
+            owner_id, path, snapshot_id, source_turn_id, updated_order_key, head_proof
+          ) VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT(owner_id, path) DO UPDATE SET
+            snapshot_id = excluded.snapshot_id,
+            source_turn_id = excluded.source_turn_id,
+            updated_order_key = excluded.updated_order_key,
+            head_proof = excluded.head_proof
+        `
+    ).run(ownerId, workspacePath, newSnapshotId, nextSourceTurnId, nextOrderKey, headProof);
+    return releasedSnapshotId;
+  }
+  changeSnapshotRefCount(snapshotId, delta) {
+    if (snapshotId === null || delta === 0) return;
+    const updated = this.db.prepare("UPDATE snapshots SET ref_count = ref_count + ? WHERE id = ?").run(delta, snapshotId);
+    if (updated.changes !== 1) {
+      throw new Error(`Failed to update turn-diff snapshot reference ${snapshotId}.`);
+    }
+  }
+  readSnapshotText(snapshotId) {
+    if (snapshotId === null) return null;
+    const snapshot = this.db.prepare("SELECT id, content_hash, raw_size FROM snapshots WHERE id = ?").get(snapshotId);
+    if (!snapshot) throw new Error(`Missing turn-diff snapshot ${snapshotId}.`);
+    const output = Buffer.allocUnsafe(snapshot.raw_size);
+    const rows = this.db.prepare(
+      `
+          SELECT c.codec, sc.raw_size, c.payload
+          FROM snapshot_chunks AS sc
+          JOIN chunks AS c ON c.hash = sc.chunk_hash
+          WHERE sc.snapshot_id = ?
+          ORDER BY sc.ordinal ASC
+        `
+    ).all(snapshotId);
+    let offset = 0;
+    for (const row of rows) {
+      const decoded = decompressChunk(row.codec, row.payload);
+      if (decoded.byteLength !== row.raw_size) {
+        throw new Error(`Turn-diff chunk length mismatch in snapshot ${snapshotId}.`);
+      }
+      decoded.copy(output, offset);
+      offset += decoded.byteLength;
+    }
+    if (offset !== snapshot.raw_size) {
+      throw new Error(`Turn-diff snapshot ${snapshotId} reconstructed ${offset} bytes.`);
+    }
+    const contentHash = createHash("sha256").update(output).digest();
+    if (!contentHash.equals(snapshot.content_hash)) {
+      throw new Error(`Turn-diff snapshot ${snapshotId} hash mismatch.`);
+    }
+    return output.toString("utf8");
+  }
+  deleteTurns(turnIds) {
+    if (turnIds.length === 0) return { snapshots: 0, chunks: 0 };
+    const placeholders = turnIds.map(() => "?").join(", ");
+    const run = this.db.transaction(() => {
+      const refs = this.db.prepare(
+        `
+            SELECT snapshot_id AS id, COUNT(*) AS reference_count
+            FROM (
+              SELECT old_snapshot_id AS snapshot_id
+              FROM turn_files
+              WHERE turn_id IN (${placeholders}) AND old_snapshot_id IS NOT NULL
+              UNION ALL
+              SELECT new_snapshot_id AS snapshot_id
+              FROM turn_files
+              WHERE turn_id IN (${placeholders}) AND new_snapshot_id IS NOT NULL
+            )
+            GROUP BY snapshot_id
+          `
+      ).all(...turnIds, ...turnIds);
+      for (const ref of refs) {
+        this.changeSnapshotRefCount(ref.id, -ref.reference_count);
+      }
+      this.db.prepare(`DELETE FROM turns WHERE id IN (${placeholders})`).run(...turnIds);
+      return this.deleteUnreferencedSnapshotsAndChunks(refs.map((ref) => ref.id));
+    });
+    return run.immediate();
+  }
+  accumulateDeletedTurns(cursor, turnIds, mode) {
+    const deleted = mode === "delete" ? this.deleteTurns(turnIds) : this.evictTurns(turnIds);
+    cursor.deletedTurns += turnIds.length;
+    cursor.deletedSnapshots += deleted.snapshots;
+    cursor.deletedChunks += deleted.chunks;
+  }
+  evictTurns(turnIds) {
+    if (turnIds.length === 0) return { snapshots: 0, chunks: 0 };
+    const placeholders = turnIds.map(() => "?").join(", ");
+    const run = this.db.transaction(() => {
+      const refs = this.db.prepare(
+        `
+            SELECT snapshot_id AS id, COUNT(*) AS reference_count
+            FROM (
+              SELECT old_snapshot_id AS snapshot_id
+              FROM turn_files
+              WHERE turn_id IN (${placeholders}) AND old_snapshot_id IS NOT NULL
+              UNION ALL
+              SELECT new_snapshot_id AS snapshot_id
+              FROM turn_files
+              WHERE turn_id IN (${placeholders}) AND new_snapshot_id IS NOT NULL
+            )
+            GROUP BY snapshot_id
+          `
+      ).all(...turnIds, ...turnIds);
+      for (const ref of refs) {
+        this.changeSnapshotRefCount(ref.id, -ref.reference_count);
+      }
+      this.db.prepare(`DELETE FROM turn_files WHERE turn_id IN (${placeholders})`).run(...turnIds);
+      this.db.prepare(`UPDATE turns SET evicted = 1 WHERE id IN (${placeholders})`).run(...turnIds);
+      return this.deleteUnreferencedSnapshotsAndChunks(refs.map((ref) => ref.id));
+    });
+    return run.immediate();
+  }
+  deletePathHeads(pathHeads) {
+    const run = this.db.transaction(() => {
+      const snapshotRefs = /* @__PURE__ */ new Map();
+      for (const head of pathHeads) {
+        const deleted = this.db.prepare(
+          `
+              DELETE FROM path_heads
+              WHERE owner_id = ?
+                AND path = ?
+                AND source_turn_id = ?
+                AND head_proof = ?
+                AND snapshot_id IS ?
+            `
+        ).run(head.owner_id, head.path, head.source_turn_id, head.head_proof, head.snapshot_id);
+        if (deleted.changes === 1 && head.snapshot_id !== null) {
+          snapshotRefs.set(head.snapshot_id, (snapshotRefs.get(head.snapshot_id) ?? 0) + 1);
+        }
+      }
+      for (const [snapshotId, referenceCount] of snapshotRefs) {
+        this.changeSnapshotRefCount(snapshotId, -referenceCount);
+      }
+      return this.deleteUnreferencedSnapshotsAndChunks(snapshotRefs.keys());
+    });
+    return run.immediate();
+  }
+  deleteUnreferencedSnapshotsAndChunks(candidateSnapshotIds) {
+    const snapshotIds = [...new Set(candidateSnapshotIds)];
+    let deletedSnapshots = 0;
+    let deletedChunks = 0;
+    for (const snapshotId of snapshotIds) {
+      const unreferenced = this.db.prepare("SELECT id FROM snapshots WHERE id = ? AND ref_count = 0").get(snapshotId);
+      if (!unreferenced) continue;
+      const chunkRefs = this.db.prepare(
+        `
+            SELECT chunk_hash AS hash, COUNT(*) AS reference_count
+            FROM snapshot_chunks
+            WHERE snapshot_id = ?
+            GROUP BY chunk_hash
+          `
+      ).all(snapshotId);
+      for (const ref of chunkRefs) {
+        const updated = this.db.prepare("UPDATE chunks SET ref_count = ref_count - ? WHERE hash = ?").run(ref.reference_count, ref.hash);
+        if (updated.changes !== 1) {
+          throw new Error("Failed to release a turn-diff chunk reference.");
+        }
+      }
+      const deletedSnapshot = this.db.prepare("DELETE FROM snapshots WHERE id = ? AND ref_count = 0").run(snapshotId);
+      if (deletedSnapshot.changes !== 1) {
+        throw new Error(`Failed to delete unreferenced turn-diff snapshot ${snapshotId}.`);
+      }
+      deletedSnapshots += 1;
+      for (const ref of chunkRefs) {
+        deletedChunks += this.db.prepare("DELETE FROM chunks WHERE hash = ? AND ref_count = 0").run(ref.hash).changes;
+      }
+    }
+    return { snapshots: deletedSnapshots, chunks: deletedChunks };
+  }
+  estimatedCompactedStorageBytes() {
+    const pageCount = this.db.pragma("page_count", { simple: true });
+    const freePages = this.db.pragma("freelist_count", { simple: true });
+    const pageSize = this.db.pragma("page_size", { simple: true });
+    return (pageCount - freePages) * pageSize + fileSize(`${this.options.dbPath}-shm`);
+  }
+  storageBytes(checkpoint = false) {
+    if (checkpoint) this.db.pragma("wal_checkpoint(TRUNCATE)");
+    const database = fileSize(this.options.dbPath);
+    const wal = fileSize(`${this.options.dbPath}-wal`);
+    const shm = fileSize(`${this.options.dbPath}-shm`);
+    return { database, wal, shm, total: database + wal + shm };
+  }
+  assertOpen() {
+    if (this.closed) throw new Error("Turn-diff store is closed.");
+  }
+}
+function assertSnapshotReadLimit(maxRawBytes) {
+  if (maxRawBytes !== void 0 && (Number.isNaN(maxRawBytes) || maxRawBytes < 0 || !Number.isSafeInteger(maxRawBytes))) {
+    throw new RangeError("Turn-diff snapshot maxRawBytes must be a non-negative safe integer.");
+  }
+}
+function exceedsSnapshotReadLimit(rawBytes, maxRawBytes) {
+  return maxRawBytes !== void 0 && rawBytes > maxRawBytes;
+}
+const expectedSchemaFingerprints = /* @__PURE__ */ new Map();
+function readSchemaObjects(db) {
+  return db.prepare(
+    `
+        SELECT type, name, tbl_name AS table_name, sql
+        FROM sqlite_master
+        WHERE substr(name, 1, 7) != 'sqlite_' AND sql IS NOT NULL
+        ORDER BY type ASC, name ASC
+      `
+  ).all();
+}
+function schemaFingerprint(rows) {
+  return rows.map((row) => `${row.type}:${row.name}:${row.table_name}:${normalizeSchemaSql(row.sql ?? "")}`).join("\n");
+}
+function normalizeSchemaSql(sql) {
+  return sql.replace(/\s+/g, " ").trim().replace(/;$/, "").toLowerCase();
+}
+function expectedSchemaFingerprint(schemaSql) {
+  const cached = expectedSchemaFingerprints.get(schemaSql);
+  if (cached !== void 0) return cached;
+  const database = new Database(":memory:");
+  try {
+    database.exec(schemaSql);
+    const fingerprint = schemaFingerprint(readSchemaObjects(database));
+    expectedSchemaFingerprints.set(schemaSql, fingerprint);
+    return fingerprint;
+  } finally {
+    database.close();
+  }
+}
+function normalizeOptions(options) {
+  const retentionDays = clampInteger(
+    options.retentionDays ?? DEFAULT_RETENTION_DAYS,
+    MIN_RETENTION_DAYS,
+    MAX_RETENTION_DAYS
+  );
+  const maxStorageBytes = positiveInteger(
+    options.maxStorageBytes ?? DEFAULT_MAX_STORAGE_BYTES,
+    "maxStorageBytes"
+  );
+  const defaultTarget = options.maxStorageBytes === void 0 ? DEFAULT_GC_TARGET_BYTES : Math.max(1, Math.floor(maxStorageBytes * 0.9));
+  const gcTargetBytes = positiveInteger(options.gcTargetBytes ?? defaultTarget, "gcTargetBytes");
+  if (gcTargetBytes >= maxStorageBytes) {
+    throw new Error("gcTargetBytes must be smaller than maxStorageBytes.");
+  }
+  return {
+    dbPath: options.dbPath,
+    retentionDays,
+    maxStorageBytes,
+    gcTargetBytes,
+    // gzip is readable by every Node version supported by the CLI. zstd remains
+    // an explicit opt-in because Node 22.14 cannot read codec-1 chunks.
+    compression: options.compression ?? "gzip"
+  };
+}
+function validateRecordInput(input) {
+  if (!input.ownerId) throw new Error("Turn-diff ownerId must not be empty.");
+  if (!input.turnId) throw new Error("Turn-diff turnId must not be empty.");
+  if (input.orderKey !== void 0 && (input.orderKey.length === 0 || input.orderKey.length > 1024 || input.orderKey.includes("\0"))) {
+    throw new Error("Turn-diff orderKey must contain 1-1024 non-NUL characters.");
+  }
+  for (const [name, value] of [
+    ["capturedAtMs", input.capturedAtMs],
+    ["recordedAtMs", input.recordedAtMs]
+  ]) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new Error(`Turn-diff ${name} must be a non-negative safe integer.`);
+    }
+  }
+  const paths = /* @__PURE__ */ new Set();
+  for (const event of input.events) {
+    if (!event.path || event.path.includes("\0")) {
+      throw new Error("Turn-diff paths must be non-empty and contain no NUL.");
+    }
+    if (paths.has(event.path)) {
+      throw new Error(`Turn-diff record contains duplicate path ${event.path}.`);
+    }
+    paths.add(event.path);
+    if (typeof event.newIsCurrent !== "boolean") {
+      throw new Error(`Turn-diff event newIsCurrent must be boolean for ${event.path}.`);
+    }
+    if (event.newIsCurrent && (!Number.isSafeInteger(event.headProof) || (event.headProof ?? 0) <= 0) || !event.newIsCurrent && event.headProof !== null) {
+      throw new Error(`Turn-diff event headProof does not match newIsCurrent for ${event.path}.`);
+    }
+    if (!Number.isSafeInteger(event.add) || event.add < 0) {
+      throw new Error(`Invalid added-line count for ${event.path}.`);
+    }
+    if (!Number.isSafeInteger(event.del) || event.del < 0) {
+      throw new Error(`Invalid deleted-line count for ${event.path}.`);
+    }
+  }
+}
+function defaultTurnOrderKey(capturedAtMs, turnId) {
+  return `${capturedAtMs.toString().padStart(16, "0")}:${turnId}`;
+}
+function clampInteger(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+function positiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive safe integer.`);
+  }
+  return value;
+}
+function fileSize(filePath) {
+  try {
+    return statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function runTurnDiffStoreWorker() {
+  if (parentPort === null) {
+    throw new Error("Turn-diff store worker must run inside a Node.js Worker.");
+  }
+  const port = parentPort;
+  let store;
+  let gcScheduled = false;
+  let gcRequested = false;
+  let gcCursor;
+  let gcRunId = 0;
+  let gcNowMs = 0;
+  const cancelScheduledGc = () => {
+    gcRunId += 1;
+    gcScheduled = false;
+    gcRequested = false;
+    gcCursor = void 0;
+  };
+  const scheduleGc = (nowMs) => {
+    if (store === void 0) return;
+    gcNowMs = Math.max(gcNowMs, nowMs);
+    if (gcScheduled) {
+      gcRequested = true;
+      return;
+    }
+    gcScheduled = true;
+    gcRequested = false;
+    const runId = ++gcRunId;
+    const runStep = () => {
+      if (runId !== gcRunId || store === void 0) return;
+      try {
+        gcCursor ??= store.beginGc(gcNowMs);
+        const result = store.gcStep(gcCursor);
+        if (result === null) {
+          setImmediate(runStep);
+          return;
+        }
+        const shouldRunAgain = gcRequested;
+        gcScheduled = false;
+        gcRequested = false;
+        gcCursor = void 0;
+        port.postMessage({ id: 0, backgroundGc: result });
+        if (shouldRunAgain) scheduleGc(gcNowMs);
+      } catch (error) {
+        gcScheduled = false;
+        gcRequested = false;
+        gcCursor = void 0;
+        port.postMessage({
+          id: 0,
+          backgroundError: formatError(error)
+        });
+      }
+    };
+    setImmediate(runStep);
+  };
+  port.on("message", (request) => {
+    try {
+      if (request.kind === "init") {
+        if (store !== void 0) throw new Error("Turn-diff store worker is already initialized.");
+        store = new SqliteTurnDiffStore(request.options);
+        const shouldRunGc = store.shouldRunGc(request.nowMs);
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: null
+        });
+        if (shouldRunGc) scheduleGc(request.nowMs);
+        return;
+      }
+      if (store === void 0) throw new Error("Turn-diff store worker is not initialized.");
+      if (request.kind === "allocate-head-proof") {
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.allocateHeadProof()
+        });
+        return;
+      }
+      if (request.kind === "record") {
+        const result = store.recordTurn(request.input);
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result
+        });
+        if (result.gcScheduled) {
+          scheduleGc(request.input.recordedAtMs);
+        }
+        return;
+      }
+      if (request.kind === "list-changed-paths") {
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.listChangedPaths(request.input)
+        });
+        return;
+      }
+      if (request.kind === "earliest-old") {
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.getEarliestOldSnapshot(request.input)
+        });
+        return;
+      }
+      if (request.kind === "turn-snapshot") {
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.getTurnSnapshot(request.input)
+        });
+        return;
+      }
+      if (request.kind === "latest-text") {
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.getLatestText(request.input)
+        });
+        return;
+      }
+      if (request.kind === "list-turn-files") {
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.listTurnFiles(request.input)
+        });
+        return;
+      }
+      if (request.kind === "gc") {
+        cancelScheduledGc();
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.gc(request.nowMs)
+        });
+        return;
+      }
+      if (request.kind === "stats") {
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: store.stats()
+        });
+        return;
+      }
+      if (request.kind === "close") {
+        cancelScheduledGc();
+        store.close();
+        store = void 0;
+        port.postMessage({
+          id: request.id,
+          kind: request.kind,
+          result: null
+        });
+        return;
+      }
+      assertNever(request);
+    } catch (error) {
+      port.postMessage({
+        id: request.id,
+        kind: request.kind,
+        error: formatError(error)
+      });
+    }
+  });
+}
+function assertNever(value) {
+  throw new Error(`Unhandled turn-diff worker request: ${JSON.stringify(value)}`);
+}
+function formatError(error) {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+runTurnDiffStoreWorker();