@tungthedev/streams-server 0.2.0

package/src/db/db.ts

@@ -0,0 +1,2424 @@
+import { initSchema } from "./schema.ts";
+import { openSqliteDatabase, type SqliteDatabase, type SqliteStatement } from "../sqlite/adapter.ts";
+import { Result } from "better-result";
+import type { StoreAppendBatch, StoreAppendTask } from "../store/append";
+import type { WalReadRow, WalStore } from "../store/wal_store";
+import type { SegmentReadStore, StreamReadStore } from "../store/segment_read_store";
+import type { ManifestPublicationSnapshot, ManifestStore, SegmentStore } from "../store/segment_manifest_store";
+import type {
+  IndexRunRow,
+  IndexStateRow,
+  LexiconIndexRunRow,
+  LexiconIndexStateRow,
+  SearchCompanionPlanRow,
+  SearchSegmentCompanionRow,
+  SecondaryIndexRunRow,
+  SecondaryIndexStateRow,
+  SegmentMetaRow,
+  SegmentRow,
+  StreamRow,
+} from "../store/rows";
+import { STREAM_FLAG_DELETED, STREAM_FLAG_TOUCH } from "../store/rows";
+import type {
+  ProfileMetadataCommit,
+  ProfileMetadataMutationContext,
+  ProfileMetadataMutationPlan,
+  ProfileStore,
+  SchemaMetadataCommit,
+  SchemaMetadataMutationContext,
+  SchemaMetadataMutationPlan,
+  SchemaStore,
+} from "../store/schema_profile_store";
+import type { WalControlPlaneStore, DurableStoreCapabilities } from "../store/capabilities";
+import type {
+  ObjectStoreAccountingStore,
+  ObjectStoreRequestCountRow,
+  ObjectStoreRequestSummary,
+  StorageStatsStore,
+} from "../store/stats_accounting_store";
+import { summarizeObjectStoreRequestCounts } from "../store/stats_accounting_store";
+import type {
+  FullModeDetailsSnapshot,
+  FullModeDetailsSnapshotRequest,
+  FullModeDetailsStore,
+  FullModeLagSnapshotRequest,
+} from "../store/full_mode_details_store";
+import { SqliteWalStore } from "./sqlite_wal_store";
+import { loadSqliteManifestPublicationSnapshot } from "./sqlite_manifest_snapshot";
+import { SqliteTouchStore } from "./sqlite_touch_store";
+
+export { STREAM_FLAG_DELETED, STREAM_FLAG_TOUCH } from "../store/rows";
+
+const BASE_WAL_GC_CHUNK_OFFSETS = (() => {
+  const raw = process.env.DS_BASE_WAL_GC_CHUNK_OFFSETS;
+  if (raw == null || raw.trim() === "") return 1_000_000;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return 1_000_000;
+  return Math.floor(n);
+})();
+
+export type {
+  IndexRunRow,
+  IndexStateRow,
+  LexiconIndexRunRow,
+  LexiconIndexStateRow,
+  SearchCompanionPlanRow,
+  SearchSegmentCompanionRow,
+  SecondaryIndexRunRow,
+  SecondaryIndexStateRow,
+  SegmentMetaRow,
+  SegmentRow,
+  StreamRow,
+} from "../store/rows";
+
+function legacyWalReadRow(row: WalReadRow): {
+  offset: bigint;
+  ts_ms: bigint;
+  routing_key: Uint8Array | null;
+  content_type: string | null;
+  payload: Uint8Array;
+} {
+  return {
+    offset: row.offset,
+    ts_ms: row.tsMs,
+    routing_key: row.routingKey,
+    content_type: row.contentType,
+    payload: row.payload,
+  };
+}
+
+export class SqliteDurableStore
+  implements
+    WalControlPlaneStore,
+    WalStore,
+    SegmentReadStore,
+    StreamReadStore,
+    SegmentStore,
+    ManifestStore,
+    SchemaStore,
+    ProfileStore,
+    StorageStatsStore,
+    ObjectStoreAccountingStore,
+    FullModeDetailsStore
+{
+  readonly kind = "sqlite" as const;
+  readonly capabilities: DurableStoreCapabilities = {
+    wal: true,
+    schemas: true,
+    profiles: true,
+    streamLifecycle: true,
+    segmentReads: true,
+    indexes: true,
+    manifests: true,
+    objectStoreAccounting: true,
+    storageStats: true,
+    schemaPublication: true,
+    builtinProfiles: true,
+    internalMetrics: true,
+    touch: true,
+  };
+
+  public readonly db: SqliteDatabase;
+  public readonly touch: SqliteTouchStore;
+  private readonly walStore: SqliteWalStore;
+  private dbstatReady: boolean | null = null;
+
+  // Prepared statements.
+  private readonly stmts: {
+    getStream: SqliteStatement;
+    upsertStream: SqliteStatement;
+    listStreams: SqliteStatement;
+    listDeletedStreams: SqliteStatement;
+    setDeleted: SqliteStatement;
+    setStreamProfile: SqliteStatement;
+
+    insertWal: SqliteStatement;
+
+    updateStreamAppend: SqliteStatement;
+    updateStreamAppendSeqCheck: SqliteStatement;
+
+    candidateStreams: SqliteStatement;
+    candidateStreamsNoInterval: SqliteStatement;
+    listExpiredStreams: SqliteStatement;
+
+    createSegment: SqliteStatement;
+    listSegmentsForStream: SqliteStatement;
+    getSegmentByIndex: SqliteStatement;
+    findSegmentForOffset: SqliteStatement;
+    nextSegmentIndex: SqliteStatement;
+    markSegmentUploaded: SqliteStatement;
+    pendingUploadHeads: SqliteStatement;
+    recentSegmentCompressionWindow: SqliteStatement;
+    countPendingSegments: SqliteStatement;
+    tryClaimSegment: SqliteStatement;
+    countSegmentsForStream: SqliteStatement;
+
+    getManifest: SqliteStatement;
+    upsertManifest: SqliteStatement;
+    setSchemaUploadedSize: SqliteStatement;
+    recordObjectStoreRequest: SqliteStatement;
+
+    getIndexState: SqliteStatement;
+    upsertIndexState: SqliteStatement;
+    updateIndexedThrough: SqliteStatement;
+    listIndexRuns: SqliteStatement;
+    listIndexRunsAll: SqliteStatement;
+    listRetiredIndexRuns: SqliteStatement;
+    insertIndexRun: SqliteStatement;
+    retireIndexRun: SqliteStatement;
+    deleteIndexRun: SqliteStatement;
+    deleteIndexStateForStream: SqliteStatement;
+    deleteIndexRunsForStream: SqliteStatement;
+    getSecondaryIndexState: SqliteStatement;
+    listSecondaryIndexStates: SqliteStatement;
+    upsertSecondaryIndexState: SqliteStatement;
+    updateSecondaryIndexedThrough: SqliteStatement;
+    listSecondaryIndexRuns: SqliteStatement;
+    listSecondaryIndexRunsAll: SqliteStatement;
+    listRetiredSecondaryIndexRuns: SqliteStatement;
+    insertSecondaryIndexRun: SqliteStatement;
+    retireSecondaryIndexRun: SqliteStatement;
+    deleteSecondaryIndexRun: SqliteStatement;
+    deleteSecondaryIndexState: SqliteStatement;
+    deleteSecondaryIndexRunsForIndex: SqliteStatement;
+    deleteSecondaryIndexStatesForStream: SqliteStatement;
+    deleteSecondaryIndexRunsForStream: SqliteStatement;
+    getLexiconIndexState: SqliteStatement;
+    listLexiconIndexStates: SqliteStatement;
+    upsertLexiconIndexState: SqliteStatement;
+    updateLexiconIndexedThrough: SqliteStatement;
+    listLexiconIndexRuns: SqliteStatement;
+    listLexiconIndexRunsAll: SqliteStatement;
+    listRetiredLexiconIndexRuns: SqliteStatement;
+    insertLexiconIndexRun: SqliteStatement;
+    retireLexiconIndexRun: SqliteStatement;
+    deleteLexiconIndexRun: SqliteStatement;
+    deleteLexiconIndexState: SqliteStatement;
+    deleteLexiconIndexRunsForSource: SqliteStatement;
+    deleteLexiconIndexStatesForStream: SqliteStatement;
+    deleteLexiconIndexRunsForStream: SqliteStatement;
+    getSearchCompanionPlan: SqliteStatement;
+    listSearchCompanionPlanStreams: SqliteStatement;
+    upsertSearchCompanionPlan: SqliteStatement;
+    deleteSearchCompanionPlan: SqliteStatement;
+    listSearchSegmentCompanions: SqliteStatement;
+    getSearchSegmentCompanion: SqliteStatement;
+    upsertSearchSegmentCompanion: SqliteStatement;
+    deleteSearchSegmentCompanionsFromGeneration: SqliteStatement;
+    deleteSearchSegmentCompanionsFromIndex: SqliteStatement;
+    deleteSearchSegmentCompanions: SqliteStatement;
+    countUploadedSegments: SqliteStatement;
+    getSegmentMeta: SqliteStatement;
+    ensureSegmentMeta: SqliteStatement;
+    appendSegmentMeta: SqliteStatement;
+    upsertSegmentMeta: SqliteStatement;
+    setUploadedSegmentCount: SqliteStatement;
+
+    advanceUploadedThrough: SqliteStatement;
+
+    getSchemaRegistry: SqliteStatement;
+    upsertSchemaRegistry: SqliteStatement;
+    getStreamProfile: SqliteStatement;
+    upsertStreamProfile: SqliteStatement;
+    deleteStreamProfile: SqliteStatement;
+    countStreams: SqliteStatement;
+    sumPendingBytes: SqliteStatement;
+    sumPendingSegmentBytes: SqliteStatement;
+  };
+
+  constructor(path: string, opts: { cacheBytes?: number; skipMigrations?: boolean } = {}) {
+    this.db = openSqliteDatabase(path);
+    initSchema(this.db, { skipMigrations: opts.skipMigrations });
+    if (opts.cacheBytes && opts.cacheBytes > 0) {
+      const kb = Math.max(1, Math.floor(opts.cacheBytes / 1024));
+      this.db.exec(`PRAGMA cache_size = -${kb};`);
+    }
+    this.walStore = new SqliteWalStore(this.db, () => this.nowMs(), STREAM_FLAG_DELETED);
+    this.touch = new SqliteTouchStore(this.db, {
+      nowMs: () => this.nowMs(),
+      getStream: (stream) => this.getStream(stream),
+      ensureStream: (stream, ensureOpts) => this.ensureStream(stream, ensureOpts),
+      addStreamFlags: (stream, flags) => this.addStreamFlags(stream, flags),
+      isDeleted: (row) => this.isDeleted(row),
+      readWalRange: (stream, startOffset, endOffset, routingKey) => this.readWalRange(stream, startOffset, endOffset, routingKey),
+      deleteWalThrough: (stream, uploadedThrough) => this.deleteWalThrough(stream, uploadedThrough),
+      getWalOldestOffset: (stream) => this.getWalOldestOffset(stream),
+      trimWalByAge: (stream, maxAgeMs) => this.trimWalByAge(stream, maxAgeMs),
+    });
+
+    this.stmts = {
+      getStream: this.db.query(
+        `SELECT stream, created_at_ms, updated_at_ms,
+                content_type, profile, stream_seq, closed, closed_producer_id, closed_producer_epoch, closed_producer_seq, ttl_seconds,
+                epoch, next_offset, sealed_through, uploaded_through, uploaded_segment_count,
+                pending_rows, pending_bytes, logical_size_bytes, wal_rows, wal_bytes, last_append_ms, last_segment_cut_ms, segment_in_progress,
+                expires_at_ms, stream_flags
+         FROM streams WHERE stream = ? LIMIT 1;`
+      ),
+      upsertStream: this.db.query(
+        `INSERT INTO streams(stream, created_at_ms, updated_at_ms,
+                             content_type, profile, stream_seq, closed, closed_producer_id, closed_producer_epoch, closed_producer_seq, ttl_seconds,
+                             epoch, next_offset, sealed_through, uploaded_through, uploaded_segment_count,
+                             pending_rows, pending_bytes, logical_size_bytes, wal_rows, wal_bytes, last_append_ms, last_segment_cut_ms, segment_in_progress,
+                             expires_at_ms, stream_flags)
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(stream) DO UPDATE SET
+           updated_at_ms=excluded.updated_at_ms,
+           expires_at_ms=excluded.expires_at_ms,
+           ttl_seconds=excluded.ttl_seconds,
+           content_type=excluded.content_type,
+           profile=excluded.profile,
+           stream_flags=excluded.stream_flags;`
+      ),
+      listStreams: this.db.query(
+        `SELECT stream, created_at_ms, updated_at_ms,
+                content_type, profile, stream_seq, closed, closed_producer_id, closed_producer_epoch, closed_producer_seq, ttl_seconds,
+                epoch, next_offset, sealed_through, uploaded_through, uploaded_segment_count,
+                pending_rows, pending_bytes, logical_size_bytes, wal_rows, wal_bytes, last_append_ms, last_segment_cut_ms, segment_in_progress,
+                expires_at_ms, stream_flags
+         FROM streams
+         WHERE (stream_flags & ?) = 0
+           AND (expires_at_ms IS NULL OR expires_at_ms > ?)
+         ORDER BY stream
+         LIMIT ? OFFSET ?;`
+      ),
+      listDeletedStreams: this.db.query(
+        `SELECT stream
+         FROM streams
+         WHERE (stream_flags & ?) != 0
+         ORDER BY stream
+         LIMIT ? OFFSET ?;`
+      ),
+      setDeleted: this.db.query(`UPDATE streams SET stream_flags = (stream_flags | ?), updated_at_ms=? WHERE stream=?;`),
+      setStreamProfile: this.db.query(`UPDATE streams SET profile=?, updated_at_ms=? WHERE stream=?;`),
+
+      insertWal: this.db.query(
+        `INSERT INTO wal(stream, offset, ts_ms, payload, payload_len, routing_key, content_type, flags)
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?);`
+      ),
+
+      updateStreamAppend: this.db.query(
+        `UPDATE streams
+         SET next_offset = ?, updated_at_ms = ?, last_append_ms = ?,
+             pending_rows = pending_rows + ?, pending_bytes = pending_bytes + ?,
+             logical_size_bytes = logical_size_bytes + ?,
+             wal_rows = wal_rows + ?, wal_bytes = wal_bytes + ?
+         WHERE stream = ? AND (stream_flags & ?) = 0;`
+      ),
+      updateStreamAppendSeqCheck: this.db.query(
+        `UPDATE streams
+         SET next_offset = ?, updated_at_ms = ?, last_append_ms = ?,
+             pending_rows = pending_rows + ?, pending_bytes = pending_bytes + ?,
+             logical_size_bytes = logical_size_bytes + ?,
+             wal_rows = wal_rows + ?, wal_bytes = wal_bytes + ?
+         WHERE stream = ? AND (stream_flags & ?) = 0 AND next_offset = ?;`
+      ),
+
+      candidateStreams: this.db.query(
+        `SELECT stream, pending_bytes, pending_rows, last_segment_cut_ms, sealed_through, next_offset, epoch
+         FROM streams
+         WHERE (stream_flags & ?) = 0
+           AND segment_in_progress = 0
+           AND (pending_bytes >= ? OR pending_rows >= ? OR (? - last_segment_cut_ms) >= ?)
+         ORDER BY pending_bytes DESC
+         LIMIT ?;`
+      ),
+      candidateStreamsNoInterval: this.db.query(
+        `SELECT stream, pending_bytes, pending_rows, last_segment_cut_ms, sealed_through, next_offset, epoch
+         FROM streams
+         WHERE (stream_flags & ?) = 0
+           AND segment_in_progress = 0
+           AND (pending_bytes >= ? OR pending_rows >= ?)
+         ORDER BY pending_bytes DESC
+         LIMIT ?;`
+      ),
+      listExpiredStreams: this.db.query(
+        `SELECT stream
+         FROM streams
+         WHERE (stream_flags & ?) = 0
+           AND expires_at_ms IS NOT NULL
+           AND expires_at_ms <= ?
+         ORDER BY expires_at_ms ASC
+         LIMIT ?;`
+      ),
+
+      createSegment: this.db.query(
+        `INSERT INTO segments(segment_id, stream, segment_index, start_offset, end_offset, block_count,
+                              last_append_ms, payload_bytes, size_bytes, local_path, created_at_ms, uploaded_at_ms, r2_etag)
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL);`
+      ),
+      listSegmentsForStream: this.db.query(
+        `SELECT segment_id, stream, segment_index, start_offset, end_offset, block_count, last_append_ms, payload_bytes, size_bytes,
+                local_path, created_at_ms, uploaded_at_ms, r2_etag
+         FROM segments WHERE stream=? ORDER BY segment_index ASC;`
+      ),
+      getSegmentByIndex: this.db.query(
+        `SELECT segment_id, stream, segment_index, start_offset, end_offset, block_count, last_append_ms, payload_bytes, size_bytes,
+                local_path, created_at_ms, uploaded_at_ms, r2_etag
+         FROM segments WHERE stream=? AND segment_index=? LIMIT 1;`
+      ),
+      findSegmentForOffset: this.db.query(
+        `SELECT segment_id, stream, segment_index, start_offset, end_offset, block_count, last_append_ms, payload_bytes, size_bytes,
+                local_path, created_at_ms, uploaded_at_ms, r2_etag
+         FROM segments
+         WHERE stream=? AND start_offset <= ? AND end_offset >= ?
+         ORDER BY segment_index DESC
+         LIMIT 1;`
+      ),
+      nextSegmentIndex: this.db.query(
+        `SELECT COALESCE(MAX(segment_index)+1, 0) as next_idx FROM segments WHERE stream=?;`
+      ),
+      markSegmentUploaded: this.db.query(
+        `UPDATE segments SET r2_etag=?, uploaded_at_ms=? WHERE segment_id=?;`
+      ),
+      pendingUploadHeads: this.db.query(
+        `SELECT segment_id, stream, segment_index, start_offset, end_offset, block_count, last_append_ms, payload_bytes, size_bytes,
+                local_path, created_at_ms, uploaded_at_ms, r2_etag
+         FROM segments s
+         WHERE s.uploaded_at_ms IS NULL
+           AND s.segment_index = (
+             SELECT MIN(s2.segment_index)
+             FROM segments s2
+             WHERE s2.stream = s.stream AND s2.uploaded_at_ms IS NULL
+           )
+         ORDER BY s.created_at_ms ASC, s.stream ASC
+         LIMIT ?;`
+      ),
+      recentSegmentCompressionWindow: this.db.query(
+        `SELECT
+           COALESCE(SUM(payload_bytes), 0) AS payload_total,
+           COALESCE(SUM(size_bytes), 0) AS size_total,
+           COUNT(*) AS cnt
+         FROM (
+           SELECT payload_bytes, size_bytes
+           FROM segments
+           WHERE stream=? AND payload_bytes > 0
+           ORDER BY segment_index DESC
+           LIMIT ?
+         );`
+      ),
+      countPendingSegments: this.db.query(`SELECT COUNT(*) as cnt FROM segments WHERE uploaded_at_ms IS NULL;`),
+      countSegmentsForStream: this.db.query(`SELECT COUNT(*) as cnt FROM segments WHERE stream=?;`),
+      tryClaimSegment: this.db.query(
+        `UPDATE streams SET segment_in_progress=1, updated_at_ms=? WHERE stream=? AND segment_in_progress=0;`
+      ),
+
+      getManifest: this.db.query(
+        `SELECT stream, generation, uploaded_generation, last_uploaded_at_ms, last_uploaded_etag, last_uploaded_size_bytes
+         FROM manifests WHERE stream=? LIMIT 1;`
+      ),
+      upsertManifest: this.db.query(
+        `INSERT INTO manifests(stream, generation, uploaded_generation, last_uploaded_at_ms, last_uploaded_etag, last_uploaded_size_bytes)
+         VALUES(?, ?, ?, ?, ?, ?)
+         ON CONFLICT(stream) DO UPDATE SET
+           generation=excluded.generation,
+           uploaded_generation=excluded.uploaded_generation,
+           last_uploaded_at_ms=excluded.last_uploaded_at_ms,
+           last_uploaded_etag=excluded.last_uploaded_etag,
+           last_uploaded_size_bytes=excluded.last_uploaded_size_bytes;`
+      ),
+
+      getIndexState: this.db.query(
+        `SELECT stream, index_secret, indexed_through, updated_at_ms
+         FROM index_state WHERE stream=? LIMIT 1;`
+      ),
+      upsertIndexState: this.db.query(
+        `INSERT INTO index_state(stream, index_secret, indexed_through, updated_at_ms)
+         VALUES(?, ?, ?, ?)
+         ON CONFLICT(stream) DO UPDATE SET
+           index_secret=excluded.index_secret,
+           indexed_through=excluded.indexed_through,
+           updated_at_ms=excluded.updated_at_ms;`
+      ),
+      updateIndexedThrough: this.db.query(
+        `UPDATE index_state SET indexed_through=?, updated_at_ms=? WHERE stream=?;`
+      ),
+      listIndexRuns: this.db.query(
+        `SELECT run_id, stream, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms
+         FROM index_runs WHERE stream=? AND retired_gen IS NULL
+         ORDER BY start_segment ASC, level ASC;`
+      ),
+      listIndexRunsAll: this.db.query(
+        `SELECT run_id, stream, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms
+         FROM index_runs WHERE stream=?
+         ORDER BY start_segment ASC, level ASC;`
+      ),
+      listRetiredIndexRuns: this.db.query(
+        `SELECT run_id, stream, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms
+         FROM index_runs WHERE stream=? AND retired_gen IS NOT NULL
+         ORDER BY retired_at_ms ASC;`
+      ),
+      insertIndexRun: this.db.query(
+        `INSERT OR IGNORE INTO index_runs(run_id, stream, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms)
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL);`
+      ),
+      retireIndexRun: this.db.query(
+        `UPDATE index_runs SET retired_gen=?, retired_at_ms=? WHERE run_id=?;`
+      ),
+      deleteIndexRun: this.db.query(
+        `DELETE FROM index_runs WHERE run_id=?;`
+      ),
+      deleteIndexStateForStream: this.db.query(`DELETE FROM index_state WHERE stream=?;`),
+      deleteIndexRunsForStream: this.db.query(`DELETE FROM index_runs WHERE stream=?;`),
+      getSecondaryIndexState: this.db.query(
+        `SELECT stream, index_name, index_secret, config_hash, indexed_through, updated_at_ms
+         FROM secondary_index_state WHERE stream=? AND index_name=? LIMIT 1;`
+      ),
+      listSecondaryIndexStates: this.db.query(
+        `SELECT stream, index_name, index_secret, config_hash, indexed_through, updated_at_ms
+         FROM secondary_index_state WHERE stream=?
+         ORDER BY index_name ASC;`
+      ),
+      upsertSecondaryIndexState: this.db.query(
+        `INSERT INTO secondary_index_state(stream, index_name, index_secret, config_hash, indexed_through, updated_at_ms)
+         VALUES(?, ?, ?, ?, ?, ?)
+         ON CONFLICT(stream, index_name) DO UPDATE SET
+           index_secret=excluded.index_secret,
+           config_hash=excluded.config_hash,
+           indexed_through=excluded.indexed_through,
+           updated_at_ms=excluded.updated_at_ms;`
+      ),
+      updateSecondaryIndexedThrough: this.db.query(
+        `UPDATE secondary_index_state
+         SET indexed_through=?, updated_at_ms=?
+         WHERE stream=? AND index_name=?;`
+      ),
+      listSecondaryIndexRuns: this.db.query(
+        `SELECT run_id, stream, index_name, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms
+         FROM secondary_index_runs
+         WHERE stream=? AND index_name=? AND retired_gen IS NULL
+         ORDER BY start_segment ASC, level ASC;`
+      ),
+      listSecondaryIndexRunsAll: this.db.query(
+        `SELECT run_id, stream, index_name, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms
+         FROM secondary_index_runs
+         WHERE stream=? AND index_name=?
+         ORDER BY start_segment ASC, level ASC;`
+      ),
+      listRetiredSecondaryIndexRuns: this.db.query(
+        `SELECT run_id, stream, index_name, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms
+         FROM secondary_index_runs
+         WHERE stream=? AND index_name=? AND retired_gen IS NOT NULL
+         ORDER BY retired_at_ms ASC;`
+      ),
+      insertSecondaryIndexRun: this.db.query(
+        `INSERT OR IGNORE INTO secondary_index_runs(run_id, stream, index_name, level, start_segment, end_segment, object_key, size_bytes, filter_len, record_count, retired_gen, retired_at_ms)
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL);`
+      ),
+      retireSecondaryIndexRun: this.db.query(
+        `UPDATE secondary_index_runs SET retired_gen=?, retired_at_ms=? WHERE run_id=?;`
+      ),
+      deleteSecondaryIndexRun: this.db.query(
+        `DELETE FROM secondary_index_runs WHERE run_id=?;`
+      ),
+      deleteSecondaryIndexState: this.db.query(`DELETE FROM secondary_index_state WHERE stream=? AND index_name=?;`),
+      deleteSecondaryIndexRunsForIndex: this.db.query(`DELETE FROM secondary_index_runs WHERE stream=? AND index_name=?;`),
+      deleteSecondaryIndexStatesForStream: this.db.query(`DELETE FROM secondary_index_state WHERE stream=?;`),
+      deleteSecondaryIndexRunsForStream: this.db.query(`DELETE FROM secondary_index_runs WHERE stream=?;`),
+      getLexiconIndexState: this.db.query(
+        `SELECT stream, source_kind, source_name, indexed_through, updated_at_ms
+         FROM lexicon_index_state
+         WHERE stream=? AND source_kind=? AND source_name=?
+         LIMIT 1;`
+      ),
+      listLexiconIndexStates: this.db.query(
+        `SELECT stream, source_kind, source_name, indexed_through, updated_at_ms
+         FROM lexicon_index_state
+         WHERE stream=?
+         ORDER BY source_kind ASC, source_name ASC;`
+      ),
+      upsertLexiconIndexState: this.db.query(
+        `INSERT INTO lexicon_index_state(stream, source_kind, source_name, indexed_through, updated_at_ms)
+         VALUES(?, ?, ?, ?, ?)
+         ON CONFLICT(stream, source_kind, source_name) DO UPDATE SET
+           indexed_through=excluded.indexed_through,
+           updated_at_ms=excluded.updated_at_ms;`
+      ),
+      updateLexiconIndexedThrough: this.db.query(
+        `UPDATE lexicon_index_state
+         SET indexed_through=?, updated_at_ms=?
+         WHERE stream=? AND source_kind=? AND source_name=?;`
+      ),
+      listLexiconIndexRuns: this.db.query(
+        `SELECT run_id, stream, source_kind, source_name, level, start_segment, end_segment, object_key, size_bytes, record_count, retired_gen, retired_at_ms
+         FROM lexicon_index_runs
+         WHERE stream=? AND source_kind=? AND source_name=? AND retired_gen IS NULL
+         ORDER BY start_segment ASC, level ASC;`
+      ),
+      listLexiconIndexRunsAll: this.db.query(
+        `SELECT run_id, stream, source_kind, source_name, level, start_segment, end_segment, object_key, size_bytes, record_count, retired_gen, retired_at_ms
+         FROM lexicon_index_runs
+         WHERE stream=? AND source_kind=? AND source_name=?
+         ORDER BY start_segment ASC, level ASC;`
+      ),
+      listRetiredLexiconIndexRuns: this.db.query(
+        `SELECT run_id, stream, source_kind, source_name, level, start_segment, end_segment, object_key, size_bytes, record_count, retired_gen, retired_at_ms
+         FROM lexicon_index_runs
+         WHERE stream=? AND source_kind=? AND source_name=? AND retired_gen IS NOT NULL
+         ORDER BY retired_at_ms ASC;`
+      ),
+      insertLexiconIndexRun: this.db.query(
+        `INSERT OR IGNORE INTO lexicon_index_runs(run_id, stream, source_kind, source_name, level, start_segment, end_segment, object_key, size_bytes, record_count, retired_gen, retired_at_ms)
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL);`
+      ),
+      retireLexiconIndexRun: this.db.query(
+        `UPDATE lexicon_index_runs SET retired_gen=?, retired_at_ms=? WHERE run_id=?;`
+      ),
+      deleteLexiconIndexRun: this.db.query(
+        `DELETE FROM lexicon_index_runs WHERE run_id=?;`
+      ),
+      deleteLexiconIndexState: this.db.query(
+        `DELETE FROM lexicon_index_state WHERE stream=? AND source_kind=? AND source_name=?;`
+      ),
+      deleteLexiconIndexRunsForSource: this.db.query(
+        `DELETE FROM lexicon_index_runs WHERE stream=? AND source_kind=? AND source_name=?;`
+      ),
+      deleteLexiconIndexStatesForStream: this.db.query(`DELETE FROM lexicon_index_state WHERE stream=?;`),
+      deleteLexiconIndexRunsForStream: this.db.query(`DELETE FROM lexicon_index_runs WHERE stream=?;`),
+      getSearchCompanionPlan: this.db.query(
+        `SELECT stream, generation, plan_hash, plan_json, updated_at_ms
+         FROM search_companion_plans WHERE stream=? LIMIT 1;`
+      ),
+      listSearchCompanionPlanStreams: this.db.query(
+        `SELECT stream FROM search_companion_plans ORDER BY stream ASC;`
+      ),
+      upsertSearchCompanionPlan: this.db.query(
+        `INSERT INTO search_companion_plans(stream, generation, plan_hash, plan_json, updated_at_ms)
+         VALUES(?, ?, ?, ?, ?)
+         ON CONFLICT(stream) DO UPDATE SET
+           generation=excluded.generation,
+           plan_hash=excluded.plan_hash,
+           plan_json=excluded.plan_json,
+           updated_at_ms=excluded.updated_at_ms;`
+      ),
+      deleteSearchCompanionPlan: this.db.query(`DELETE FROM search_companion_plans WHERE stream=?;`),
+      listSearchSegmentCompanions: this.db.query(
+        `SELECT stream, segment_index, object_key, plan_generation, sections_json, section_sizes_json, size_bytes,
+                primary_timestamp_min_ms, primary_timestamp_max_ms, updated_at_ms
+         FROM search_segment_companions
+         WHERE stream=?
+         ORDER BY segment_index ASC;`
+      ),
+      getSearchSegmentCompanion: this.db.query(
+        `SELECT stream, segment_index, object_key, plan_generation, sections_json, section_sizes_json, size_bytes,
+                primary_timestamp_min_ms, primary_timestamp_max_ms, updated_at_ms
+         FROM search_segment_companions
+         WHERE stream=? AND segment_index=? LIMIT 1;`
+      ),
+      upsertSearchSegmentCompanion: this.db.query(
+        `INSERT INTO search_segment_companions(stream, segment_index, object_key, plan_generation, sections_json, section_sizes_json, size_bytes,
+                                               primary_timestamp_min_ms, primary_timestamp_max_ms, updated_at_ms)
+         VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(stream, segment_index) DO UPDATE SET
+           object_key=excluded.object_key,
+           plan_generation=excluded.plan_generation,
+           sections_json=excluded.sections_json,
+           section_sizes_json=excluded.section_sizes_json,
+           size_bytes=excluded.size_bytes,
+           primary_timestamp_min_ms=excluded.primary_timestamp_min_ms,
+           primary_timestamp_max_ms=excluded.primary_timestamp_max_ms,
+           updated_at_ms=excluded.updated_at_ms;`
+      ),
+      deleteSearchSegmentCompanionsFromGeneration: this.db.query(
+        `DELETE FROM search_segment_companions WHERE stream=? AND plan_generation < ?;`
+      ),
+      deleteSearchSegmentCompanionsFromIndex: this.db.query(
+        `DELETE FROM search_segment_companions WHERE stream=? AND segment_index >= ?;`
+      ),
+      deleteSearchSegmentCompanions: this.db.query(`DELETE FROM search_segment_companions WHERE stream=?;`),
+      countUploadedSegments: this.db.query(
+        `SELECT COALESCE(MAX(segment_index), -1) as max_idx
+         FROM segments WHERE stream=? AND r2_etag IS NOT NULL;`
+      ),
+      getSegmentMeta: this.db.query(
+        `SELECT stream, segment_count, segment_offsets, segment_blocks, segment_last_ts
+         FROM stream_segment_meta WHERE stream=? LIMIT 1;`
+      ),
+      ensureSegmentMeta: this.db.query(
+        `INSERT INTO stream_segment_meta(stream, segment_count, segment_offsets, segment_blocks, segment_last_ts)
+         VALUES(?, 0, x'', x'', x'')
+         ON CONFLICT(stream) DO NOTHING;`
+      ),
+      appendSegmentMeta: this.db.query(
+        `UPDATE stream_segment_meta
+         SET segment_count = segment_count + 1,
+             segment_offsets = segment_offsets || ?,
+             segment_blocks = segment_blocks || ?,
+             segment_last_ts = segment_last_ts || ?
+         WHERE stream = ?;`
+      ),
+      upsertSegmentMeta: this.db.query(
+        `INSERT INTO stream_segment_meta(stream, segment_count, segment_offsets, segment_blocks, segment_last_ts)
+         VALUES(?, ?, ?, ?, ?)
+         ON CONFLICT(stream) DO UPDATE SET
+           segment_count=excluded.segment_count,
+           segment_offsets=excluded.segment_offsets,
+           segment_blocks=excluded.segment_blocks,
+           segment_last_ts=excluded.segment_last_ts;`
+      ),
+      setUploadedSegmentCount: this.db.query(
+        `UPDATE streams SET uploaded_segment_count=?, updated_at_ms=? WHERE stream=?;`
+      ),
+
+      advanceUploadedThrough: this.db.query(
+        `UPDATE streams SET uploaded_through=?, updated_at_ms=? WHERE stream=?;`
+      ),
+
+      getSchemaRegistry: this.db.query(`SELECT stream, schema_json, updated_at_ms, uploaded_size_bytes FROM schemas WHERE stream=? LIMIT 1;`),
+      upsertSchemaRegistry: this.db.query(
+        `INSERT INTO schemas(stream, schema_json, updated_at_ms) VALUES(?, ?, ?)
+         ON CONFLICT(stream) DO UPDATE SET schema_json=excluded.schema_json, updated_at_ms=excluded.updated_at_ms;`
+      ),
+      setSchemaUploadedSize: this.db.query(`UPDATE schemas SET uploaded_size_bytes=?, updated_at_ms=? WHERE stream=?;`),
+      getStreamProfile: this.db.query(`SELECT stream, profile_json, updated_at_ms FROM stream_profiles WHERE stream=? LIMIT 1;`),
+      upsertStreamProfile: this.db.query(
+        `INSERT INTO stream_profiles(stream, profile_json, updated_at_ms) VALUES(?, ?, ?)
+         ON CONFLICT(stream) DO UPDATE SET profile_json=excluded.profile_json, updated_at_ms=excluded.updated_at_ms;`
+      ),
+      deleteStreamProfile: this.db.query(`DELETE FROM stream_profiles WHERE stream=?;`),
+      countStreams: this.db.query(`SELECT COUNT(*) as cnt FROM streams WHERE (stream_flags & ?) = 0;`),
+      sumPendingBytes: this.db.query(`SELECT COALESCE(SUM(pending_bytes), 0) as total FROM streams;`),
+      sumPendingSegmentBytes: this.db.query(`SELECT COALESCE(SUM(size_bytes), 0) as total FROM segments WHERE uploaded_at_ms IS NULL;`),
+      recordObjectStoreRequest: this.db.query(
+        `INSERT INTO objectstore_request_counts(stream_hash, artifact, op, count, bytes, updated_at_ms)
+         VALUES(?, ?, ?, ?, ?, ?)
+         ON CONFLICT(stream_hash, artifact, op) DO UPDATE SET
+           count=objectstore_request_counts.count + excluded.count,
+           bytes=objectstore_request_counts.bytes + excluded.bytes,
+           updated_at_ms=excluded.updated_at_ms;`
+      ),
+    };
+  }
+
+  private toBigInt(v: any): bigint {
+    return typeof v === "bigint" ? v : BigInt(v);
+  }
+
+  private bindInt(v: bigint): number | string {
+    const max = BigInt(Number.MAX_SAFE_INTEGER);
+    const min = BigInt(Number.MIN_SAFE_INTEGER);
+    if (v <= max && v >= min) return Number(v);
+    return v.toString();
+  }
+
+  private deleteWalThroughWithStats(
+    stream: string,
+    through: bigint,
+    opts?: { maxRows?: number }
+  ): { deletedRows: bigint; deletedBytes: bigint } {
+    if (through < 0n) return { deletedRows: 0n, deletedBytes: 0n };
+    const bound = this.bindInt(through);
+    const maxRows = opts?.maxRows;
+    const useChunkedDelete = typeof maxRows === "number" && Number.isFinite(maxRows) && maxRows > 0;
+    const stmt = useChunkedDelete
+      ? this.db.prepare(
+          `DELETE FROM wal
+           WHERE rowid IN (
+             SELECT rowid
+             FROM wal
+             WHERE stream=? AND offset <= ?
+             ORDER BY offset ASC
+             LIMIT ?
+           )
+           RETURNING payload_len;`
+        )
+      : this.db.prepare(
+          `DELETE FROM wal
+           WHERE stream=? AND offset <= ?
+           RETURNING payload_len;`
+        );
+
+    try {
+      const rows = useChunkedDelete
+        ? stmt.iterate(stream, bound, Math.max(1, Math.floor(maxRows!)))
+        : stmt.iterate(stream, bound);
+
+      let deletedRows = 0n;
+      let deletedBytes = 0n;
+      for (const row of rows as any) {
+        deletedRows += 1n;
+        deletedBytes += this.toBigInt(row?.payload_len ?? 0);
+      }
+      return { deletedRows, deletedBytes };
+    } finally {
+      try {
+        stmt.finalize?.();
+      } catch {
+        // ignore
+      }
+    }
+  }
+
+  private encodeU64Le(value: bigint): Uint8Array {
+    const buf = new Uint8Array(8);
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    dv.setBigUint64(0, value, true);
+    return buf;
+  }
+
+  private encodeU32Le(value: number): Uint8Array {
+    const buf = new Uint8Array(4);
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    dv.setUint32(0, value >>> 0, true);
+    return buf;
+  }
+
+  private coerceStreamRow(row: any): StreamRow {
+    return {
+      stream: String(row.stream),
+      created_at_ms: this.toBigInt(row.created_at_ms),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+      content_type: String(row.content_type),
+      profile: row.profile == null ? null : String(row.profile),
+      stream_seq: row.stream_seq == null ? null : String(row.stream_seq),
+      closed: Number(row.closed),
+      closed_producer_id: row.closed_producer_id == null ? null : String(row.closed_producer_id),
+      closed_producer_epoch: row.closed_producer_epoch == null ? null : Number(row.closed_producer_epoch),
+      closed_producer_seq: row.closed_producer_seq == null ? null : Number(row.closed_producer_seq),
+      ttl_seconds: row.ttl_seconds == null ? null : Number(row.ttl_seconds),
+      epoch: Number(row.epoch),
+      next_offset: this.toBigInt(row.next_offset),
+      sealed_through: this.toBigInt(row.sealed_through),
+      uploaded_through: this.toBigInt(row.uploaded_through),
+      uploaded_segment_count: Number(row.uploaded_segment_count ?? 0),
+      pending_rows: this.toBigInt(row.pending_rows),
+      pending_bytes: this.toBigInt(row.pending_bytes),
+      logical_size_bytes: this.toBigInt(row.logical_size_bytes ?? 0),
+      wal_rows: this.toBigInt(row.wal_rows ?? 0),
+      wal_bytes: this.toBigInt(row.wal_bytes ?? 0),
+      last_append_ms: this.toBigInt(row.last_append_ms),
+      last_segment_cut_ms: this.toBigInt(row.last_segment_cut_ms),
+      segment_in_progress: Number(row.segment_in_progress),
+      expires_at_ms: row.expires_at_ms == null ? null : this.toBigInt(row.expires_at_ms),
+      stream_flags: Number(row.stream_flags),
+    };
+  }
+
+  private coerceSegmentRow(row: any): SegmentRow {
+    return {
+      segment_id: String(row.segment_id),
+      stream: String(row.stream),
+      segment_index: Number(row.segment_index),
+      start_offset: this.toBigInt(row.start_offset),
+      end_offset: this.toBigInt(row.end_offset),
+      block_count: Number(row.block_count),
+      last_append_ms: this.toBigInt(row.last_append_ms),
+      payload_bytes: this.toBigInt(row.payload_bytes ?? 0),
+      size_bytes: Number(row.size_bytes),
+      local_path: String(row.local_path),
+      created_at_ms: this.toBigInt(row.created_at_ms),
+      uploaded_at_ms: row.uploaded_at_ms == null ? null : this.toBigInt(row.uploaded_at_ms),
+      r2_etag: row.r2_etag == null ? null : String(row.r2_etag),
+    };
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  nowMs(): bigint {
+    return BigInt(Date.now());
+  }
+
+  isDeleted(row: StreamRow): boolean {
+    return (row.stream_flags & STREAM_FLAG_DELETED) !== 0;
+  }
+
+  getStream(stream: string): StreamRow | null {
+    const row = this.stmts.getStream.get(stream) as any;
+    return row ? this.coerceStreamRow(row) : null;
+  }
+
+  setStreamLogicalSizeBytes(stream: string, logicalSizeBytes: bigint): void {
+    this.db
+      .query(`UPDATE streams SET logical_size_bytes=?, updated_at_ms=? WHERE stream=?;`)
+      .run(this.bindInt(logicalSizeBytes), this.nowMs(), stream);
+  }
+
+  listStreamsMissingLogicalSize(limit: number): string[] {
+    const now = this.nowMs();
+    const rows = this.db
+      .query(
+        `SELECT stream
+         FROM streams
+         WHERE (stream_flags & ?) = 0
+           AND (expires_at_ms IS NULL OR expires_at_ms > ?)
+           AND next_offset > 0
+           AND logical_size_bytes = 0
+         ORDER BY updated_at_ms ASC
+         LIMIT ?;`
+      )
+      .all(STREAM_FLAG_DELETED | STREAM_FLAG_TOUCH, now, limit) as any[];
+    return rows.map((row) => String(row.stream));
+  }
+
+  getWalBytesAfterOffset(stream: string, offset: bigint): bigint {
+    const row = this.db
+      .query(
+        `SELECT COALESCE(SUM(payload_len), 0) as bytes
+         FROM wal
+         WHERE stream=? AND offset > ?;`
+      )
+      .get(stream, this.bindInt(offset)) as any;
+    return this.toBigInt(row?.bytes ?? 0);
+  }
+
+  ensureStream(
+    stream: string,
+    opts?: {
+      contentType?: string;
+      profile?: string | null;
+      expiresAtMs?: bigint | null;
+      ttlSeconds?: number | null;
+      closed?: boolean;
+      closedProducer?: { id: string; epoch: number; seq: number } | null;
+      streamFlags?: number;
+    }
+  ): StreamRow {
+    const existing = this.getStream(stream);
+    if (existing) return existing;
+
+    const now = this.nowMs();
+    const epoch = 0;
+    const nextOffset = 0n;
+    const contentType = opts?.contentType ?? "application/octet-stream";
+    const profile = opts?.profile ?? "generic";
+    const closed = opts?.closed ? 1 : 0;
+    const closedProducer = opts?.closedProducer ?? null;
+    const expiresAtMs = opts?.expiresAtMs ?? null;
+    const ttlSeconds = opts?.ttlSeconds ?? null;
+    const streamFlags = opts?.streamFlags ?? 0;
+
+    this.db
+      .query(
+        `INSERT INTO streams(
+          stream, created_at_ms, updated_at_ms,
+          content_type, profile, stream_seq, closed, closed_producer_id, closed_producer_epoch, closed_producer_seq, ttl_seconds,
+          epoch, next_offset, sealed_through, uploaded_through, uploaded_segment_count,
+          pending_rows, pending_bytes, logical_size_bytes, last_append_ms, last_segment_cut_ms, segment_in_progress,
+          expires_at_ms, stream_flags
+        )
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);`
+      )
+      .run(
+        stream,
+        now,
+        now,
+        contentType,
+        profile,
+        null,
+        closed,
+        closedProducer ? closedProducer.id : null,
+        closedProducer ? closedProducer.epoch : null,
+        closedProducer ? closedProducer.seq : null,
+        ttlSeconds,
+        epoch,
+        nextOffset,
+        -1n,
+        -1n,
+        0,
+        0n,
+        0n,
+        0n,
+        now,
+        now,
+        0,
+        expiresAtMs,
+        streamFlags
+      );
+
+    this.stmts.upsertManifest.run(stream, 0, 0, null, null, null);
+    this.ensureSegmentMeta(stream);
+    return this.getStream(stream)!;
+  }
+
+  restoreStreamRow(row: StreamRow): void {
+    this.stmts.upsertStream.run(
+      row.stream,
+      row.created_at_ms,
+      row.updated_at_ms,
+      row.content_type,
+      row.profile,
+      row.stream_seq,
+      row.closed,
+      row.closed_producer_id,
+      row.closed_producer_epoch,
+      row.closed_producer_seq,
+      row.ttl_seconds,
+      row.epoch,
+      row.next_offset,
+      row.sealed_through,
+      row.uploaded_through,
+      row.uploaded_segment_count,
+      row.pending_rows,
+      row.pending_bytes,
+      row.logical_size_bytes,
+      row.wal_rows,
+      row.wal_bytes,
+      row.last_append_ms,
+      row.last_segment_cut_ms,
+      row.segment_in_progress,
+      row.expires_at_ms,
+      row.stream_flags
+    );
+  }
+
+  listStreams(limit: number, offset: number): StreamRow[] {
+    const now = this.nowMs();
+    const rows = this.stmts.listStreams.all(STREAM_FLAG_DELETED | STREAM_FLAG_TOUCH, now, limit, offset) as any[];
+    return rows.map((r) => this.coerceStreamRow(r));
+  }
+
+  listDeletedStreams(limit: number, offset: number): string[] {
+    const rows = this.stmts.listDeletedStreams.all(STREAM_FLAG_DELETED, limit, offset) as any[];
+    return rows.map((row) => String(row.stream));
+  }
+
+  listExpiredStreams(limit: number): string[] {
+    const now = this.nowMs();
+    const rows = this.stmts.listExpiredStreams.all(STREAM_FLAG_DELETED | STREAM_FLAG_TOUCH, now, limit) as any[];
+    return rows.map((r) => String(r.stream));
+  }
+
+  deleteAccelerationState(stream: string): void {
+    const tx = this.db.transaction(() => {
+      this.stmts.deleteIndexRunsForStream.run(stream);
+      this.stmts.deleteIndexStateForStream.run(stream);
+      this.stmts.deleteSecondaryIndexRunsForStream.run(stream);
+      this.stmts.deleteSecondaryIndexStatesForStream.run(stream);
+      this.stmts.deleteLexiconIndexRunsForStream.run(stream);
+      this.stmts.deleteLexiconIndexStatesForStream.run(stream);
+      this.stmts.deleteSearchSegmentCompanions.run(stream);
+      this.stmts.deleteSearchCompanionPlan.run(stream);
+    });
+    tx();
+  }
+
+  deleteStream(stream: string): boolean {
+    const existing = this.getStream(stream);
+    if (!existing) return false;
+    const now = this.nowMs();
+    const tx = this.db.transaction(() => {
+      this.stmts.setDeleted.run(STREAM_FLAG_DELETED, now, stream);
+      this.stmts.deleteIndexRunsForStream.run(stream);
+      this.stmts.deleteIndexStateForStream.run(stream);
+      this.stmts.deleteSecondaryIndexRunsForStream.run(stream);
+      this.stmts.deleteSecondaryIndexStatesForStream.run(stream);
+      this.stmts.deleteLexiconIndexRunsForStream.run(stream);
+      this.stmts.deleteLexiconIndexStatesForStream.run(stream);
+      this.stmts.deleteSearchSegmentCompanions.run(stream);
+      this.stmts.deleteSearchCompanionPlan.run(stream);
+    });
+    tx();
+    return true;
+  }
+
+  updateStreamProfile(stream: string, profile: string | null): StreamRow | null {
+    this.stmts.setStreamProfile.run(profile, this.nowMs(), stream);
+    return this.getStream(stream);
+  }
+
+  hardDeleteStream(stream: string): boolean {
+    const tx = this.db.transaction(() => {
+      const existing = this.getStream(stream);
+      if (!existing) return false;
+      this.db.query(`DELETE FROM wal WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM segments WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM manifests WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM schemas WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM stream_profiles WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM stream_touch_state WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM live_templates WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM producer_state WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM index_state WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM index_runs WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM secondary_index_state WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM secondary_index_runs WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM lexicon_index_state WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM lexicon_index_runs WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM search_companion_plans WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM search_segment_companions WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM stream_segment_meta WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM streams WHERE stream=?;`).run(stream);
+      return true;
+    });
+    return tx();
+  }
+
+  getSchemaRegistry(stream: string): { stream: string; registry_json: string; updated_at_ms: bigint; uploaded_size_bytes: bigint } | null {
+    const row = this.stmts.getSchemaRegistry.get(stream) as any;
+    if (!row) return null;
+    return {
+      stream: String(row.stream),
+      registry_json: String(row.schema_json),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+      uploaded_size_bytes: this.toBigInt(row.uploaded_size_bytes ?? 0),
+    };
+  }
+
+  async getSchemaRegistryForRead(
+    stream: string
+  ): Promise<{ stream: string; registry_json: string; updated_at_ms: bigint; uploaded_size_bytes: bigint } | null> {
+    return this.getSchemaRegistry(stream);
+  }
+
+  async commitSchemaMetadataMutation<T, E>(
+    stream: string,
+    mutation: (ctx: SchemaMetadataMutationContext) => Result<SchemaMetadataMutationPlan<T>, E>
+  ): Promise<Result<SchemaMetadataCommit<T>, E>> {
+    const tx = this.db.transaction(() => {
+      const streamRow = this.getStream(stream);
+      const registryRow = this.getSchemaRegistry(stream);
+      const mutationRes = mutation({ streamRow, registryRow });
+      if (Result.isError(mutationRes)) return mutationRes;
+      const updatedAtMs = this.nowMs();
+      this.stmts.upsertSchemaRegistry.run(stream, mutationRes.value.registryJson, updatedAtMs);
+      return Result.ok({
+        registry: mutationRes.value.registry,
+        updatedAtMs,
+        value: mutationRes.value.value,
+      });
+    });
+    return tx();
+  }
+
+  upsertSchemaRegistry(stream: string, registryJson: string): void {
+    this.stmts.upsertSchemaRegistry.run(stream, registryJson, this.nowMs());
+  }
+
+  setSchemaUploadedSizeBytes(stream: string, sizeBytes: number): void {
+    this.stmts.setSchemaUploadedSize.run(sizeBytes, this.nowMs(), stream);
+  }
+
+  getStreamProfile(stream: string): { stream: string; profile_json: string; updated_at_ms: bigint } | null {
+    const row = this.stmts.getStreamProfile.get(stream) as any;
+    if (!row) return null;
+    return {
+      stream: String(row.stream),
+      profile_json: String(row.profile_json),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    };
+  }
+
+  async getStreamProfileForRead(stream: string): Promise<{ stream: string; profile_json: string; updated_at_ms: bigint } | null> {
+    return this.getStreamProfile(stream);
+  }
+
+  async commitProfileMetadataMutation<T, E>(
+    stream: string,
+    mutation: (ctx: ProfileMetadataMutationContext) => Result<ProfileMetadataMutationPlan<T>, E>
+  ): Promise<Result<ProfileMetadataCommit<T>, E>> {
+    const tx = this.db.transaction(() => {
+      const streamRow = this.getStream(stream);
+      const profileRow = this.getStreamProfile(stream);
+      const mutationRes = mutation({ streamRow, profileRow });
+      if (Result.isError(mutationRes)) return mutationRes;
+
+      const updatedAtMs = this.nowMs();
+      const metadata = mutationRes.value.metadata;
+      this.stmts.setStreamProfile.run(metadata.streamProfile, updatedAtMs, stream);
+      if (metadata.schemaRegistry) {
+        this.stmts.upsertSchemaRegistry.run(stream, JSON.stringify(metadata.schemaRegistry), updatedAtMs);
+      }
+      if (metadata.profileJson == null) this.stmts.deleteStreamProfile.run(stream);
+      else this.stmts.upsertStreamProfile.run(stream, metadata.profileJson, updatedAtMs);
+      if (metadata.touchState === "ensure" && streamRow) {
+        this.db
+          .query(
+            `INSERT OR IGNORE INTO stream_touch_state(stream, processed_through, updated_at_ms)
+             VALUES(?, ?, ?);`
+          )
+          .run(stream, this.bindInt(streamRow.next_offset - 1n), updatedAtMs);
+      } else if (metadata.touchState === "delete") {
+        this.db.query(`DELETE FROM stream_touch_state WHERE stream=?;`).run(stream);
+      }
+
+      return Result.ok({
+        schemaRegistry: metadata.schemaRegistry,
+        profileUpdatedAtMs: updatedAtMs,
+        value: mutationRes.value.value,
+      });
+    });
+    return tx();
+  }
+
+  upsertStreamProfile(stream: string, profileJson: string): void {
+    this.stmts.upsertStreamProfile.run(stream, profileJson, this.nowMs());
+  }
+
+  deleteStreamProfile(stream: string): void {
+    this.stmts.deleteStreamProfile.run(stream);
+  }
+
+  addStreamFlags(stream: string, flags: number): void {
+    if (!Number.isFinite(flags) || flags <= 0) return;
+    this.db.query(`UPDATE streams SET stream_flags = (stream_flags | ?), updated_at_ms=? WHERE stream=?;`).run(flags, this.nowMs(), stream);
+  }
+
+  getWalOldestOffset(stream: string): bigint | null {
+    const row = this.db.query(`SELECT MIN(offset) as min_off FROM wal WHERE stream=?;`).get(stream) as any;
+    if (!row || row.min_off == null) return null;
+    return this.toBigInt(row.min_off);
+  }
+
+  getWalOldestTimestampMs(stream: string): bigint | null {
+    const row = this.db.query(`SELECT MIN(ts_ms) as min_ts FROM wal WHERE stream=?;`).get(stream) as any;
+    if (!row || row.min_ts == null) return null;
+    return this.toBigInt(row.min_ts);
+  }
+
+  /**
+   * Trim a WAL-only stream by age (in ms), leaving at least 1 record if the stream is non-empty.
+   *
+   * This is primarily intended for internal companion touch streams which are not segmented/uploaded.
+   */
+  trimWalByAge(stream: string, maxAgeMs: number): { trimmedRows: number; trimmedBytes: number; keptFromOffset: bigint | null } {
+    const ageMs = Math.max(0, Math.floor(maxAgeMs));
+    if (!Number.isFinite(ageMs)) return { trimmedRows: 0, trimmedBytes: 0, keptFromOffset: null };
+
+    const tx = this.db.transaction(() => {
+      const lastRow = this.db.query(`SELECT offset, ts_ms FROM wal WHERE stream=? ORDER BY offset DESC LIMIT 1;`).get(stream) as any;
+      if (!lastRow || lastRow.offset == null) return { trimmedRows: 0, trimmedBytes: 0, keptFromOffset: null };
+      const lastOffset = this.toBigInt(lastRow.offset);
+
+      let keepFromOffset: bigint;
+      if (ageMs === 0) {
+        // maxAgeMs=0 means "keep only the newest row" (still leaving 1 record).
+        keepFromOffset = lastOffset;
+      } else {
+        const cutoff = this.nowMs() - BigInt(ageMs);
+        const keepRow = this.db
+          .query(`SELECT offset FROM wal WHERE stream=? AND ts_ms >= ? ORDER BY offset ASC LIMIT 1;`)
+          .get(stream, this.bindInt(cutoff)) as any;
+        keepFromOffset = keepRow && keepRow.offset != null ? this.toBigInt(keepRow.offset) : lastOffset;
+      }
+
+      if (keepFromOffset <= 0n) return { trimmedRows: 0, trimmedBytes: 0, keptFromOffset: keepFromOffset };
+
+      const { deletedRows: rows, deletedBytes: bytes } = this.deleteWalThroughWithStats(stream, keepFromOffset - 1n);
+      if (rows <= 0n) return { trimmedRows: 0, trimmedBytes: 0, keptFromOffset: keepFromOffset };
+
+      // Touch streams are WAL-only: pending_* tracks WAL payload bytes/rows. Keep it consistent for stats/backpressure.
+      const now = this.nowMs();
+      this.db.query(
+        `UPDATE streams
+         SET pending_bytes = CASE WHEN pending_bytes >= ? THEN pending_bytes - ? ELSE 0 END,
+             pending_rows = CASE WHEN pending_rows >= ? THEN pending_rows - ? ELSE 0 END,
+             wal_bytes = CASE WHEN wal_bytes >= ? THEN wal_bytes - ? ELSE 0 END,
+             wal_rows = CASE WHEN wal_rows >= ? THEN wal_rows - ? ELSE 0 END,
+             updated_at_ms = ?
+         WHERE stream = ?;`
+      ).run(bytes, bytes, rows, rows, bytes, bytes, rows, rows, now, stream);
+
+      const trimmedBytes = bytes <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(bytes) : Number.MAX_SAFE_INTEGER;
+      const trimmedRows = rows <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(rows) : Number.MAX_SAFE_INTEGER;
+      return { trimmedRows, trimmedBytes, keptFromOffset: keepFromOffset };
+    });
+    return tx();
+  }
+
+  countStreams(): number {
+    const row = this.stmts.countStreams.get(STREAM_FLAG_DELETED | STREAM_FLAG_TOUCH) as any;
+    return row ? Number(row.cnt) : 0;
+  }
+
+  sumPendingBytes(): number {
+    const row = this.stmts.sumPendingBytes.get() as any;
+    const total = row?.total ?? 0;
+    return Number(this.toBigInt(total));
+  }
+
+  sumPendingSegmentBytes(): number {
+    const row = this.stmts.sumPendingSegmentBytes.get() as any;
+    const total = row?.total ?? 0;
+    return Number(this.toBigInt(total));
+  }
+
+  private ensureDbStat(): boolean {
+    if (this.dbstatReady != null) return this.dbstatReady;
+    try {
+      this.db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS temp.dbstat USING dbstat;");
+      this.dbstatReady = true;
+    } catch {
+      this.dbstatReady = false;
+    }
+    return this.dbstatReady;
+  }
+
+  private estimateWalBytes(): number {
+    try {
+      const row = this.db.query(
+        `SELECT
+           COALESCE(SUM(payload_len), 0) as payload,
+           COALESCE(SUM(LENGTH(routing_key)), 0) as rk,
+           COALESCE(SUM(LENGTH(content_type)), 0) as ct
+         FROM wal;`
+      ).get() as any;
+      return Number(row?.payload ?? 0) + Number(row?.rk ?? 0) + Number(row?.ct ?? 0);
+    } catch {
+      return 0;
+    }
+  }
+
+  private estimateMetaBytes(): number {
+    try {
+      const streams = this.db.query(
+        `SELECT
+           COALESCE(SUM(LENGTH(stream)), 0) as stream,
+           COALESCE(SUM(LENGTH(content_type)), 0) as content_type,
+           COALESCE(SUM(LENGTH(stream_seq)), 0) as stream_seq,
+           COALESCE(SUM(LENGTH(closed_producer_id)), 0) as closed_producer_id
+         FROM streams;`
+      ).get() as any;
+      const segments = this.db.query(
+        `SELECT
+           COALESCE(SUM(LENGTH(segment_id)), 0) as segment_id,
+           COALESCE(SUM(LENGTH(stream)), 0) as stream,
+           COALESCE(SUM(LENGTH(local_path)), 0) as local_path,
+           COALESCE(SUM(LENGTH(r2_etag)), 0) as r2_etag
+         FROM segments;`
+      ).get() as any;
+      const manifests = this.db.query(
+        `SELECT
+           COALESCE(SUM(LENGTH(stream)), 0) as stream,
+           COALESCE(SUM(LENGTH(last_uploaded_etag)), 0) as last_uploaded_etag
+         FROM manifests;`
+      ).get() as any;
+      const schemas = this.db.query(`SELECT COALESCE(SUM(LENGTH(schema_json)), 0) as schema_json FROM schemas;`).get() as any;
+      const producers = this.db.query(
+        `SELECT
+           COALESCE(SUM(LENGTH(stream)), 0) as stream,
+           COALESCE(SUM(LENGTH(producer_id)), 0) as producer_id
+         FROM producer_state;`
+      ).get() as any;
+      const total =
+        Number(streams?.stream ?? 0) +
+        Number(streams?.content_type ?? 0) +
+        Number(streams?.stream_seq ?? 0) +
+        Number(streams?.closed_producer_id ?? 0) +
+        Number(segments?.segment_id ?? 0) +
+        Number(segments?.stream ?? 0) +
+        Number(segments?.local_path ?? 0) +
+        Number(segments?.r2_etag ?? 0) +
+        Number(manifests?.stream ?? 0) +
+        Number(manifests?.last_uploaded_etag ?? 0) +
+        Number(schemas?.schema_json ?? 0) +
+        Number(producers?.stream ?? 0) +
+        Number(producers?.producer_id ?? 0);
+      return total;
+    } catch {
+      return 0;
+    }
+  }
+
+  getWalDbSizeBytes(): number {
+    if (this.ensureDbStat()) {
+      try {
+        const row = this.db.query(`SELECT COALESCE(SUM(pgsize), 0) as total FROM temp.dbstat WHERE name = 'wal';`).get() as any;
+        return Number(row?.total ?? 0);
+      } catch {
+        // fall through
+      }
+    }
+    return this.estimateWalBytes();
+  }
+
+  getMetaDbSizeBytes(): number {
+    if (this.ensureDbStat()) {
+      try {
+        const row = this.db
+          .query(`SELECT COALESCE(SUM(pgsize), 0) as total FROM temp.dbstat WHERE name != 'wal';`)
+          .get() as any;
+        return Number(row?.total ?? 0);
+      } catch {
+        // fall through
+      }
+    }
+    return this.estimateMetaBytes();
+  }
+
+  /**
+   * Append rows into WAL inside a transaction.
+   *
+   * Returns the last offset written.
+   */
+  appendWalRows(args: {
+    stream: string;
+    startOffset: bigint;
+    expectedOffset?: bigint;
+    baseAppendMs: bigint;
+    rows: Array<{ routingKey: Uint8Array | null; contentType: string | null; payload: Uint8Array; appendMs: bigint }>;
+  }): Result<
+    { lastOffset: bigint },
+    { kind: "no_rows" | "stream_missing" | "stream_expired" } | { kind: "seq_mismatch"; expectedNext: bigint }
+  > {
+    const { stream, startOffset, expectedOffset, rows } = args;
+    if (rows.length === 0) return Result.err({ kind: "no_rows" });
+
+    const tx = this.db.transaction(() => {
+      const st = this.getStream(stream);
+      if (!st || this.isDeleted(st)) return Result.err({ kind: "stream_missing" as const });
+      if (st.expires_at_ms != null && this.nowMs() > st.expires_at_ms) return Result.err({ kind: "stream_expired" as const });
+
+      if (expectedOffset !== undefined && st.next_offset !== expectedOffset) {
+        return Result.err({ kind: "seq_mismatch" as const, expectedNext: st.next_offset });
+      }
+
+      let totalBytes = 0n;
+      let offset = startOffset;
+      for (const r of rows) {
+        const payloadLen = r.payload.byteLength;
+        totalBytes += BigInt(payloadLen);
+        this.stmts.insertWal.run(stream, offset, r.appendMs, r.payload, payloadLen, r.routingKey, r.contentType, 0);
+        offset += 1n;
+      }
+
+      const lastOffset = offset - 1n;
+      const newNextOffset = lastOffset + 1n;
+      const now = this.nowMs();
+      const pendingRows = BigInt(rows.length);
+      const lastAppend = rows[rows.length - 1].appendMs;
+
+      this.stmts.updateStreamAppend.run(
+        newNextOffset,
+        now,
+        lastAppend,
+        pendingRows,
+        totalBytes,
+        totalBytes,
+        pendingRows,
+        totalBytes,
+        stream,
+        STREAM_FLAG_DELETED
+      );
+
+      return Result.ok({ lastOffset });
+    });
+
+    return tx();
+  }
+
+  async appendBatch(batch: StoreAppendTask[]): Promise<StoreAppendBatch> {
+    return this.walStore.appendBatch(batch);
+  }
+
+  readWalRange(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array) {
+    return this.walStore.readWalRange(stream, startOffset, endOffset, routingKey);
+  }
+
+  readWalRangeDesc(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array) {
+    return this.walStore.readWalRangeDesc(stream, startOffset, endOffset, routingKey);
+  }
+
+  async getWalOldestTimestampMsForRead(stream: string): Promise<bigint | null> {
+    return this.walStore.getWalOldestTimestampMsForRead(stream);
+  }
+
+  async nowMsForRead(): Promise<bigint> {
+    return this.nowMs();
+  }
+
+  async getStreamForRead(stream: string): Promise<StreamRow | null> {
+    return this.getStream(stream);
+  }
+
+  getSegmentStreamState(stream: string): StreamRow | null {
+    return this.getStream(stream);
+  }
+
+  async listSegmentsForRead(stream: string): Promise<SegmentRow[]> {
+    return this.listSegmentsForStream(stream);
+  }
+
+  async getSegmentByIndexForRead(stream: string, segmentIndex: number): Promise<SegmentRow | null> {
+    return this.getSegmentByIndex(stream, segmentIndex);
+  }
+
+  async findSegmentForOffsetForRead(stream: string, offset: bigint): Promise<SegmentRow | null> {
+    return this.findSegmentForOffset(stream, offset);
+  }
+
+  async countSegmentsForRead(stream: string): Promise<number> {
+    return this.countSegmentsForStream(stream);
+  }
+
+  async getSearchCompanionPlanForRead(stream: string): Promise<SearchCompanionPlanRow | null> {
+    return this.getSearchCompanionPlan(stream);
+  }
+
+  async listSearchSegmentCompanionsForRead(stream: string): Promise<SearchSegmentCompanionRow[]> {
+    return this.listSearchSegmentCompanions(stream);
+  }
+
+  async getSearchSegmentCompanionForRead(stream: string, segmentIndex: number): Promise<SearchSegmentCompanionRow | null> {
+    return this.getSearchSegmentCompanion(stream, segmentIndex);
+  }
+
+  /**
+   * Query WAL rows within a range.
+   * Uses iterate() for bounded memory.
+   */
+  *iterWalRange(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array): Generator<any, void, void> {
+    for (const row of this.walStore.iterWalRange(stream, startOffset, endOffset, routingKey)) {
+      yield legacyWalReadRow(row);
+    }
+  }
+
+  *iterWalRangeDesc(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array): Generator<any, void, void> {
+    for (const row of this.walStore.iterWalRangeDesc(stream, startOffset, endOffset, routingKey)) {
+      yield legacyWalReadRow(row);
+    }
+  }
+
+  nextSegmentIndexForStream(stream: string): number {
+    const row = this.stmts.nextSegmentIndex.get(stream) as any;
+    return Number(row?.next_idx ?? 0);
+  }
+
+  createSegmentRow(row: {
+    segmentId: string;
+    stream: string;
+    segmentIndex: number;
+    startOffset: bigint;
+    endOffset: bigint;
+    blockCount: number;
+    lastAppendMs: bigint;
+    payloadBytes: bigint;
+    sizeBytes: number;
+    localPath: string;
+  }): void {
+    this.stmts.createSegment.run(
+      row.segmentId,
+      row.stream,
+      row.segmentIndex,
+      row.startOffset,
+      row.endOffset,
+      row.blockCount,
+      row.lastAppendMs,
+      row.payloadBytes,
+      row.sizeBytes,
+      row.localPath,
+      this.nowMs()
+    );
+  }
+
+  commitSealedSegment(row: {
+    segmentId: string;
+    stream: string;
+    segmentIndex: number;
+    startOffset: bigint;
+    endOffset: bigint;
+    blockCount: number;
+    lastAppendMs: bigint;
+    payloadBytes: bigint;
+    sizeBytes: number;
+    localPath: string;
+    rowsSealed: bigint;
+  }): void {
+    const tx = this.db.transaction(() => {
+      this.createSegmentRow(row);
+      this.appendSegmentMeta(row.stream, row.endOffset + 1n, row.blockCount, row.lastAppendMs * 1_000_000n);
+      this.setStreamSealedThrough(row.stream, row.endOffset, row.payloadBytes, row.rowsSealed);
+    });
+    tx();
+  }
+
+  listSegmentsForStream(stream: string): SegmentRow[] {
+    const rows = this.stmts.listSegmentsForStream.all(stream) as any[];
+    return rows.map((r) => this.coerceSegmentRow(r));
+  }
+
+  getSegmentByIndex(stream: string, segmentIndex: number): SegmentRow | null {
+    const row = this.stmts.getSegmentByIndex.get(stream, segmentIndex) as any;
+    return row ? this.coerceSegmentRow(row) : null;
+  }
+
+  findSegmentForOffset(stream: string, offset: bigint): SegmentRow | null {
+    const bound = this.bindInt(offset);
+    const row = this.stmts.findSegmentForOffset.get(stream, bound, bound) as any;
+    return row ? this.coerceSegmentRow(row) : null;
+  }
+
+  pendingUploadHeads(limit: number): SegmentRow[] {
+    const rows = this.stmts.pendingUploadHeads.all(limit) as any[];
+    return rows.map((r) => this.coerceSegmentRow(r));
+  }
+
+  recentSegmentCompressionRatio(stream: string, limit = 8): number | null {
+    const row = this.stmts.recentSegmentCompressionWindow.get(stream, Math.max(1, limit)) as any;
+    const count = Number(row?.cnt ?? 0);
+    if (!Number.isFinite(count) || count <= 0) return null;
+    const payloadTotal = this.toBigInt(row?.payload_total ?? 0);
+    const sizeTotal = this.toBigInt(row?.size_total ?? 0);
+    if (payloadTotal <= 0n || sizeTotal <= 0n) return null;
+    return Number(sizeTotal) / Number(payloadTotal);
+  }
+
+  countPendingSegments(): number {
+    const row = this.stmts.countPendingSegments.get() as any;
+    return row ? Number(row.cnt) : 0;
+  }
+
+  countSegmentsForStream(stream: string): number {
+    const row = this.stmts.countSegmentsForStream.get(stream) as any;
+    return row ? Number(row.cnt) : 0;
+  }
+
+  getSegmentMeta(stream: string): SegmentMetaRow | null {
+    const row = this.stmts.getSegmentMeta.get(stream) as any;
+    if (!row) return null;
+    const offsets = row.segment_offsets instanceof Uint8Array ? row.segment_offsets : new Uint8Array(row.segment_offsets);
+    const blocks = row.segment_blocks instanceof Uint8Array ? row.segment_blocks : new Uint8Array(row.segment_blocks);
+    const lastTs = row.segment_last_ts instanceof Uint8Array ? row.segment_last_ts : new Uint8Array(row.segment_last_ts);
+    return {
+      stream: String(row.stream),
+      segment_count: Number(row.segment_count),
+      segment_offsets: offsets,
+      segment_blocks: blocks,
+      segment_last_ts: lastTs,
+    };
+  }
+
+  ensureSegmentMeta(stream: string): void {
+    this.stmts.ensureSegmentMeta.run(stream);
+  }
+
+  appendSegmentMeta(stream: string, offsetPlusOne: bigint, blockCount: number, lastAppendNs: bigint): void {
+    this.ensureSegmentMeta(stream);
+    const offsetBytes = this.encodeU64Le(offsetPlusOne);
+    const blockBytes = this.encodeU32Le(blockCount);
+    const tsBytes = this.encodeU64Le(lastAppendNs);
+    this.stmts.appendSegmentMeta.run(offsetBytes, blockBytes, tsBytes, stream);
+  }
+
+  upsertSegmentMeta(stream: string, count: number, offsets: Uint8Array, blocks: Uint8Array, lastTs: Uint8Array): void {
+    this.stmts.upsertSegmentMeta.run(stream, count, offsets, blocks, lastTs);
+  }
+
+  rebuildSegmentMeta(stream: string): SegmentMetaRow {
+    const rows = this.db
+      .query(
+        `SELECT end_offset, block_count, last_append_ms
+         FROM segments WHERE stream=? ORDER BY segment_index ASC;`
+      )
+      .all(stream) as any[];
+    const count = rows.length;
+    const offsets = new Uint8Array(count * 8);
+    const blocks = new Uint8Array(count * 4);
+    const lastTs = new Uint8Array(count * 8);
+    const dvOffsets = new DataView(offsets.buffer, offsets.byteOffset, offsets.byteLength);
+    const dvBlocks = new DataView(blocks.buffer, blocks.byteOffset, blocks.byteLength);
+    const dvLastTs = new DataView(lastTs.buffer, lastTs.byteOffset, lastTs.byteLength);
+    for (let i = 0; i < rows.length; i++) {
+      const endOffset = this.toBigInt(rows[i].end_offset);
+      const blockCount = Number(rows[i].block_count);
+      const lastAppendMs = this.toBigInt(rows[i].last_append_ms);
+      dvOffsets.setBigUint64(i * 8, endOffset + 1n, true);
+      dvBlocks.setUint32(i * 4, blockCount >>> 0, true);
+      dvLastTs.setBigUint64(i * 8, lastAppendMs * 1_000_000n, true);
+    }
+    this.upsertSegmentMeta(stream, count, offsets, blocks, lastTs);
+    return { stream, segment_count: count, segment_offsets: offsets, segment_blocks: blocks, segment_last_ts: lastTs };
+  }
+
+  setUploadedSegmentCount(stream: string, count: number): void {
+    this.stmts.setUploadedSegmentCount.run(count, this.nowMs(), stream);
+  }
+
+  advanceUploadedSegmentCount(stream: string): number {
+    const row = this.getStream(stream);
+    if (!row) return 0;
+    let count = row.uploaded_segment_count ?? 0;
+    for (;;) {
+      const seg = this.getSegmentByIndex(stream, count);
+      if (!seg || !seg.r2_etag) break;
+      count += 1;
+    }
+    if (count !== row.uploaded_segment_count) {
+      this.stmts.setUploadedSegmentCount.run(count, this.nowMs(), stream);
+    }
+    return count;
+  }
+
+  markSegmentUploaded(segmentId: string, etag: string, uploadedAtMs: bigint): void {
+    this.stmts.markSegmentUploaded.run(etag, uploadedAtMs, segmentId);
+  }
+
+  setStreamSealedThrough(stream: string, sealedThrough: bigint, bytesSealed: bigint, rowsSealed: bigint): void {
+    const now = this.nowMs();
+    this.db.query(
+      `UPDATE streams
+       SET sealed_through = ?,
+           pending_bytes = CASE WHEN pending_bytes >= ? THEN pending_bytes - ? ELSE 0 END,
+           pending_rows = CASE WHEN pending_rows >= ? THEN pending_rows - ? ELSE 0 END,
+           last_segment_cut_ms = ?,
+           updated_at_ms = ?
+       WHERE stream = ?;`
+    ).run(sealedThrough, bytesSealed, bytesSealed, rowsSealed, rowsSealed, now, now, stream);
+  }
+
+  setSegmentInProgress(stream: string, inProgress: number): void {
+    this.db.query(`UPDATE streams SET segment_in_progress=?, updated_at_ms=? WHERE stream=?;`).run(inProgress, this.nowMs(), stream);
+  }
+
+  tryClaimSegment(stream: string): { token: string } | null {
+    const res = this.stmts.tryClaimSegment.run(this.nowMs(), stream) as any;
+    const changes = typeof res?.changes === "bigint" ? res.changes : BigInt(Number(res?.changes ?? 0));
+    return changes > 0n ? { token: "sqlite" } : null;
+  }
+
+  resetSegmentInProgress(): void {
+    this.db.query(`UPDATE streams SET segment_in_progress=0 WHERE segment_in_progress != 0;`).run();
+  }
+
+  advanceUploadedThrough(stream: string, uploadedThrough: bigint): void {
+    this.stmts.advanceUploadedThrough.run(uploadedThrough, this.nowMs(), stream);
+  }
+
+  deleteWalThrough(stream: string, uploadedThrough: bigint): { deletedRows: number; deletedBytes: number } {
+    const tx = this.db.transaction(() => {
+      const { deletedRows: rows, deletedBytes: bytes } = this.deleteWalThroughWithStats(stream, uploadedThrough);
+      if (rows <= 0n) return { deletedRows: 0, deletedBytes: 0 };
+
+      const now = this.nowMs();
+      this.db.query(
+        `UPDATE streams
+         SET wal_bytes = CASE WHEN wal_bytes >= ? THEN wal_bytes - ? ELSE 0 END,
+             wal_rows = CASE WHEN wal_rows >= ? THEN wal_rows - ? ELSE 0 END,
+             updated_at_ms = ?
+         WHERE stream = ?;`
+      ).run(bytes, bytes, rows, rows, now, stream);
+
+      const deletedBytes = bytes <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(bytes) : Number.MAX_SAFE_INTEGER;
+      const deletedRows = rows <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(rows) : Number.MAX_SAFE_INTEGER;
+      return { deletedRows, deletedBytes };
+    });
+    return tx();
+  }
+
+  getManifestRow(stream: string): {
+    stream: string;
+    generation: number;
+    uploaded_generation: number;
+    last_uploaded_at_ms: bigint | null;
+    last_uploaded_etag: string | null;
+    last_uploaded_size_bytes: bigint | null;
+  } {
+    const row = this.stmts.getManifest.get(stream) as any;
+    if (!row) {
+      this.stmts.upsertManifest.run(stream, 0, 0, null, null, null);
+      const fresh = this.stmts.getManifest.get(stream) as any;
+      return {
+        stream: String(fresh.stream),
+        generation: Number(fresh.generation),
+        uploaded_generation: Number(fresh.uploaded_generation),
+        last_uploaded_at_ms: fresh.last_uploaded_at_ms == null ? null : this.toBigInt(fresh.last_uploaded_at_ms),
+        last_uploaded_etag: fresh.last_uploaded_etag == null ? null : String(fresh.last_uploaded_etag),
+        last_uploaded_size_bytes: fresh.last_uploaded_size_bytes == null ? null : this.toBigInt(fresh.last_uploaded_size_bytes),
+      };
+    }
+    return {
+      stream: String(row.stream),
+      generation: Number(row.generation),
+      uploaded_generation: Number(row.uploaded_generation),
+      last_uploaded_at_ms: row.last_uploaded_at_ms == null ? null : this.toBigInt(row.last_uploaded_at_ms),
+      last_uploaded_etag: row.last_uploaded_etag == null ? null : String(row.last_uploaded_etag),
+      last_uploaded_size_bytes: row.last_uploaded_size_bytes == null ? null : this.toBigInt(row.last_uploaded_size_bytes),
+    };
+  }
+
+  upsertManifestRow(
+    stream: string,
+    generation: number,
+    uploadedGeneration: number,
+    uploadedAtMs: bigint | null,
+    etag: string | null,
+    sizeBytes: number | null
+  ): void {
+    this.stmts.upsertManifest.run(stream, generation, uploadedGeneration, uploadedAtMs, etag, sizeBytes);
+  }
+
+  loadManifestPublicationSnapshot(stream: string): ManifestPublicationSnapshot | null {
+    return loadSqliteManifestPublicationSnapshot(this, stream);
+  }
+
+  getSegmentForManifestCleanup(stream: string, segmentIndex: number): SegmentRow | null {
+    return this.getSegmentByIndex(stream, segmentIndex);
+  }
+
+  getIndexState(stream: string): IndexStateRow | null {
+    const row = this.stmts.getIndexState.get(stream) as any;
+    if (!row) return null;
+    return {
+      stream: String(row.stream),
+      index_secret: row.index_secret instanceof Uint8Array ? row.index_secret : new Uint8Array(row.index_secret),
+      indexed_through: Number(row.indexed_through),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    };
+  }
+
+  upsertIndexState(stream: string, indexSecret: Uint8Array, indexedThrough: number): void {
+    this.stmts.upsertIndexState.run(stream, indexSecret, indexedThrough, this.nowMs());
+  }
+
+  updateIndexedThrough(stream: string, indexedThrough: number): void {
+    this.stmts.updateIndexedThrough.run(indexedThrough, this.nowMs(), stream);
+  }
+
+  listIndexRuns(stream: string): IndexRunRow[] {
+    const rows = this.stmts.listIndexRuns.all(stream) as any[];
+    return rows.map((r) => ({
+      run_id: String(r.run_id),
+      stream: String(r.stream),
+      level: Number(r.level),
+      start_segment: Number(r.start_segment),
+      end_segment: Number(r.end_segment),
+      object_key: String(r.object_key),
+      size_bytes: Number(r.size_bytes ?? 0),
+      filter_len: Number(r.filter_len),
+      record_count: Number(r.record_count),
+      retired_gen: r.retired_gen == null ? null : Number(r.retired_gen),
+      retired_at_ms: r.retired_at_ms == null ? null : this.toBigInt(r.retired_at_ms),
+    }));
+  }
+
+  listIndexRunsAll(stream: string): IndexRunRow[] {
+    const rows = this.stmts.listIndexRunsAll.all(stream) as any[];
+    return rows.map((r) => ({
+      run_id: String(r.run_id),
+      stream: String(r.stream),
+      level: Number(r.level),
+      start_segment: Number(r.start_segment),
+      end_segment: Number(r.end_segment),
+      object_key: String(r.object_key),
+      size_bytes: Number(r.size_bytes ?? 0),
+      filter_len: Number(r.filter_len),
+      record_count: Number(r.record_count),
+      retired_gen: r.retired_gen == null ? null : Number(r.retired_gen),
+      retired_at_ms: r.retired_at_ms == null ? null : this.toBigInt(r.retired_at_ms),
+    }));
+  }
+
+  listRetiredIndexRuns(stream: string): IndexRunRow[] {
+    const rows = this.stmts.listRetiredIndexRuns.all(stream) as any[];
+    return rows.map((r) => ({
+      run_id: String(r.run_id),
+      stream: String(r.stream),
+      level: Number(r.level),
+      start_segment: Number(r.start_segment),
+      end_segment: Number(r.end_segment),
+      object_key: String(r.object_key),
+      size_bytes: Number(r.size_bytes ?? 0),
+      filter_len: Number(r.filter_len),
+      record_count: Number(r.record_count),
+      retired_gen: r.retired_gen == null ? null : Number(r.retired_gen),
+      retired_at_ms: r.retired_at_ms == null ? null : this.toBigInt(r.retired_at_ms),
+    }));
+  }
+
+  insertIndexRun(row: Omit<IndexRunRow, "retired_gen" | "retired_at_ms">): void {
+    this.stmts.insertIndexRun.run(
+      row.run_id,
+      row.stream,
+      row.level,
+      row.start_segment,
+      row.end_segment,
+      row.object_key,
+      row.size_bytes,
+      row.filter_len,
+      row.record_count
+    );
+  }
+
+  retireIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): void {
+    if (runIds.length === 0) return;
+    const tx = this.db.transaction(() => {
+      for (const runId of runIds) {
+        this.stmts.retireIndexRun.run(retiredGen, retiredAtMs, runId);
+      }
+    });
+    tx();
+  }
+
+  deleteIndexRuns(runIds: string[]): void {
+    if (runIds.length === 0) return;
+    const tx = this.db.transaction(() => {
+      for (const runId of runIds) {
+        this.stmts.deleteIndexRun.run(runId);
+      }
+    });
+    tx();
+  }
+
+  deleteIndex(stream: string): void {
+    const tx = this.db.transaction(() => {
+      this.db.query(`DELETE FROM index_runs WHERE stream=?;`).run(stream);
+      this.db.query(`DELETE FROM index_state WHERE stream=?;`).run(stream);
+    });
+    tx();
+  }
+
+  countUploadedSegments(stream: string): number {
+    const row = this.stmts.countUploadedSegments.get(stream) as any;
+    const maxIdx = row ? Number(row.max_idx) : -1;
+    return maxIdx >= 0 ? maxIdx + 1 : 0;
+  }
+
+  getSecondaryIndexState(stream: string, indexName: string): SecondaryIndexStateRow | null {
+    const row = this.stmts.getSecondaryIndexState.get(stream, indexName) as any;
+    if (!row) return null;
+    return {
+      stream: String(row.stream),
+      index_name: String(row.index_name),
+      index_secret: row.index_secret instanceof Uint8Array ? row.index_secret : new Uint8Array(row.index_secret),
+      config_hash: String(row.config_hash ?? ""),
+      indexed_through: Number(row.indexed_through),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    };
+  }
+
+  listSecondaryIndexStates(stream: string): SecondaryIndexStateRow[] {
+    const rows = this.stmts.listSecondaryIndexStates.all(stream) as any[];
+    return rows.map((row) => ({
+      stream: String(row.stream),
+      index_name: String(row.index_name),
+      index_secret: row.index_secret instanceof Uint8Array ? row.index_secret : new Uint8Array(row.index_secret),
+      config_hash: String(row.config_hash ?? ""),
+      indexed_through: Number(row.indexed_through),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    }));
+  }
+
+  upsertSecondaryIndexState(
+    stream: string,
+    indexName: string,
+    indexSecret: Uint8Array,
+    configHash: string,
+    indexedThrough: number
+  ): void {
+    this.stmts.upsertSecondaryIndexState.run(stream, indexName, indexSecret, configHash, indexedThrough, this.nowMs());
+  }
+
+  updateSecondaryIndexedThrough(stream: string, indexName: string, indexedThrough: number): void {
+    this.stmts.updateSecondaryIndexedThrough.run(indexedThrough, this.nowMs(), stream, indexName);
+  }
+
+  listSecondaryIndexRuns(stream: string, indexName: string): SecondaryIndexRunRow[] {
+    const rows = this.stmts.listSecondaryIndexRuns.all(stream, indexName) as any[];
+    return rows.map((r) => ({
+      run_id: String(r.run_id),
+      stream: String(r.stream),
+      index_name: String(r.index_name),
+      level: Number(r.level),
+      start_segment: Number(r.start_segment),
+      end_segment: Number(r.end_segment),
+      object_key: String(r.object_key),
+      size_bytes: Number(r.size_bytes ?? 0),
+      filter_len: Number(r.filter_len),
+      record_count: Number(r.record_count),
+      retired_gen: r.retired_gen == null ? null : Number(r.retired_gen),
+      retired_at_ms: r.retired_at_ms == null ? null : this.toBigInt(r.retired_at_ms),
+    }));
+  }
+
+  listSecondaryIndexRunsAll(stream: string, indexName: string): SecondaryIndexRunRow[] {
+    const rows = this.stmts.listSecondaryIndexRunsAll.all(stream, indexName) as any[];
+    return rows.map((r) => ({
+      run_id: String(r.run_id),
+      stream: String(r.stream),
+      index_name: String(r.index_name),
+      level: Number(r.level),
+      start_segment: Number(r.start_segment),
+      end_segment: Number(r.end_segment),
+      object_key: String(r.object_key),
+      size_bytes: Number(r.size_bytes ?? 0),
+      filter_len: Number(r.filter_len),
+      record_count: Number(r.record_count),
+      retired_gen: r.retired_gen == null ? null : Number(r.retired_gen),
+      retired_at_ms: r.retired_at_ms == null ? null : this.toBigInt(r.retired_at_ms),
+    }));
+  }
+
+  listRetiredSecondaryIndexRuns(stream: string, indexName: string): SecondaryIndexRunRow[] {
+    const rows = this.stmts.listRetiredSecondaryIndexRuns.all(stream, indexName) as any[];
+    return rows.map((r) => ({
+      run_id: String(r.run_id),
+      stream: String(r.stream),
+      index_name: String(r.index_name),
+      level: Number(r.level),
+      start_segment: Number(r.start_segment),
+      end_segment: Number(r.end_segment),
+      object_key: String(r.object_key),
+      size_bytes: Number(r.size_bytes ?? 0),
+      filter_len: Number(r.filter_len),
+      record_count: Number(r.record_count),
+      retired_gen: r.retired_gen == null ? null : Number(r.retired_gen),
+      retired_at_ms: r.retired_at_ms == null ? null : this.toBigInt(r.retired_at_ms),
+    }));
+  }
+
+  insertSecondaryIndexRun(row: Omit<SecondaryIndexRunRow, "retired_gen" | "retired_at_ms">): void {
+    this.stmts.insertSecondaryIndexRun.run(
+      row.run_id,
+      row.stream,
+      row.index_name,
+      row.level,
+      row.start_segment,
+      row.end_segment,
+      row.object_key,
+      row.size_bytes,
+      row.filter_len,
+      row.record_count
+    );
+  }
+
+  retireSecondaryIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): void {
+    if (runIds.length === 0) return;
+    const tx = this.db.transaction(() => {
+      for (const runId of runIds) {
+        this.stmts.retireSecondaryIndexRun.run(retiredGen, retiredAtMs, runId);
+      }
+    });
+    tx();
+  }
+
+  deleteSecondaryIndexRuns(runIds: string[]): void {
+    if (runIds.length === 0) return;
+    const tx = this.db.transaction(() => {
+      for (const runId of runIds) {
+        this.stmts.deleteSecondaryIndexRun.run(runId);
+      }
+    });
+    tx();
+  }
+
+  deleteSecondaryIndex(stream: string, indexName: string): void {
+    const tx = this.db.transaction(() => {
+      this.stmts.deleteSecondaryIndexRunsForIndex.run(stream, indexName);
+      this.stmts.deleteSecondaryIndexState.run(stream, indexName);
+    });
+    tx();
+  }
+
+  getLexiconIndexState(stream: string, sourceKind: string, sourceName: string): LexiconIndexStateRow | null {
+    const row = this.stmts.getLexiconIndexState.get(stream, sourceKind, sourceName) as any;
+    if (!row) return null;
+    return {
+      stream: String(row.stream),
+      source_kind: String(row.source_kind),
+      source_name: String(row.source_name),
+      indexed_through: Number(row.indexed_through),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    };
+  }
+
+  listLexiconIndexStates(stream: string): LexiconIndexStateRow[] {
+    const rows = this.stmts.listLexiconIndexStates.all(stream) as any[];
+    return rows.map((row) => ({
+      stream: String(row.stream),
+      source_kind: String(row.source_kind),
+      source_name: String(row.source_name),
+      indexed_through: Number(row.indexed_through),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    }));
+  }
+
+  upsertLexiconIndexState(stream: string, sourceKind: string, sourceName: string, indexedThrough: number): void {
+    this.stmts.upsertLexiconIndexState.run(stream, sourceKind, sourceName, indexedThrough, this.nowMs());
+  }
+
+  updateLexiconIndexedThrough(stream: string, sourceKind: string, sourceName: string, indexedThrough: number): void {
+    this.stmts.updateLexiconIndexedThrough.run(indexedThrough, this.nowMs(), stream, sourceKind, sourceName);
+  }
+
+  listLexiconIndexRuns(stream: string, sourceKind: string, sourceName: string): LexiconIndexRunRow[] {
+    const rows = this.stmts.listLexiconIndexRuns.all(stream, sourceKind, sourceName) as any[];
+    return rows.map((row) => ({
+      run_id: String(row.run_id),
+      stream: String(row.stream),
+      source_kind: String(row.source_kind),
+      source_name: String(row.source_name),
+      level: Number(row.level),
+      start_segment: Number(row.start_segment),
+      end_segment: Number(row.end_segment),
+      object_key: String(row.object_key),
+      size_bytes: Number(row.size_bytes ?? 0),
+      record_count: Number(row.record_count ?? 0),
+      retired_gen: row.retired_gen == null ? null : Number(row.retired_gen),
+      retired_at_ms: row.retired_at_ms == null ? null : this.toBigInt(row.retired_at_ms),
+    }));
+  }
+
+  listLexiconIndexRunsAll(stream: string, sourceKind: string, sourceName: string): LexiconIndexRunRow[] {
+    const rows = this.stmts.listLexiconIndexRunsAll.all(stream, sourceKind, sourceName) as any[];
+    return rows.map((row) => ({
+      run_id: String(row.run_id),
+      stream: String(row.stream),
+      source_kind: String(row.source_kind),
+      source_name: String(row.source_name),
+      level: Number(row.level),
+      start_segment: Number(row.start_segment),
+      end_segment: Number(row.end_segment),
+      object_key: String(row.object_key),
+      size_bytes: Number(row.size_bytes ?? 0),
+      record_count: Number(row.record_count ?? 0),
+      retired_gen: row.retired_gen == null ? null : Number(row.retired_gen),
+      retired_at_ms: row.retired_at_ms == null ? null : this.toBigInt(row.retired_at_ms),
+    }));
+  }
+
+  listRetiredLexiconIndexRuns(stream: string, sourceKind: string, sourceName: string): LexiconIndexRunRow[] {
+    const rows = this.stmts.listRetiredLexiconIndexRuns.all(stream, sourceKind, sourceName) as any[];
+    return rows.map((row) => ({
+      run_id: String(row.run_id),
+      stream: String(row.stream),
+      source_kind: String(row.source_kind),
+      source_name: String(row.source_name),
+      level: Number(row.level),
+      start_segment: Number(row.start_segment),
+      end_segment: Number(row.end_segment),
+      object_key: String(row.object_key),
+      size_bytes: Number(row.size_bytes ?? 0),
+      record_count: Number(row.record_count ?? 0),
+      retired_gen: row.retired_gen == null ? null : Number(row.retired_gen),
+      retired_at_ms: row.retired_at_ms == null ? null : this.toBigInt(row.retired_at_ms),
+    }));
+  }
+
+  insertLexiconIndexRun(row: Omit<LexiconIndexRunRow, "retired_gen" | "retired_at_ms">): void {
+    this.stmts.insertLexiconIndexRun.run(
+      row.run_id,
+      row.stream,
+      row.source_kind,
+      row.source_name,
+      row.level,
+      row.start_segment,
+      row.end_segment,
+      row.object_key,
+      row.size_bytes,
+      row.record_count
+    );
+  }
+
+  retireLexiconIndexRuns(runIds: string[], retiredGen: number, retiredAtMs: bigint): void {
+    if (runIds.length === 0) return;
+    const tx = this.db.transaction(() => {
+      for (const runId of runIds) {
+        this.stmts.retireLexiconIndexRun.run(retiredGen, retiredAtMs, runId);
+      }
+    });
+    tx();
+  }
+
+  deleteLexiconIndexRuns(runIds: string[]): void {
+    if (runIds.length === 0) return;
+    const tx = this.db.transaction(() => {
+      for (const runId of runIds) {
+        this.stmts.deleteLexiconIndexRun.run(runId);
+      }
+    });
+    tx();
+  }
+
+  deleteLexiconIndexSource(stream: string, sourceKind: string, sourceName: string): void {
+    const tx = this.db.transaction(() => {
+      this.stmts.deleteLexiconIndexRunsForSource.run(stream, sourceKind, sourceName);
+      this.stmts.deleteLexiconIndexState.run(stream, sourceKind, sourceName);
+    });
+    tx();
+  }
+
+  getSearchCompanionPlan(stream: string): SearchCompanionPlanRow | null {
+    const row = this.stmts.getSearchCompanionPlan.get(stream) as any;
+    if (!row) return null;
+    return {
+      stream: String(row.stream),
+      generation: Number(row.generation),
+      plan_hash: String(row.plan_hash),
+      plan_json: String(row.plan_json),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    };
+  }
+
+  listSearchCompanionPlanStreams(): string[] {
+    const rows = this.stmts.listSearchCompanionPlanStreams.all() as any[];
+    return rows.map((row) => String(row.stream));
+  }
+
+  upsertSearchCompanionPlan(stream: string, generation: number, planHash: string, planJson: string): void {
+    this.stmts.upsertSearchCompanionPlan.run(stream, generation, planHash, planJson, this.nowMs());
+  }
+
+  deleteSearchCompanionPlan(stream: string): void {
+    this.stmts.deleteSearchCompanionPlan.run(stream);
+  }
+
+  listSearchSegmentCompanions(stream: string): SearchSegmentCompanionRow[] {
+    const rows = this.stmts.listSearchSegmentCompanions.all(stream) as any[];
+    return rows.map((row) => ({
+      stream: String(row.stream),
+      segment_index: Number(row.segment_index),
+      object_key: String(row.object_key),
+      plan_generation: Number(row.plan_generation),
+      sections_json: String(row.sections_json),
+      section_sizes_json: String(row.section_sizes_json ?? "{}"),
+      size_bytes: Number(row.size_bytes ?? 0),
+      primary_timestamp_min_ms: row.primary_timestamp_min_ms == null ? null : this.toBigInt(row.primary_timestamp_min_ms),
+      primary_timestamp_max_ms: row.primary_timestamp_max_ms == null ? null : this.toBigInt(row.primary_timestamp_max_ms),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    }));
+  }
+
+  getSearchSegmentCompanion(stream: string, segmentIndex: number): SearchSegmentCompanionRow | null {
+    const row = this.stmts.getSearchSegmentCompanion.get(stream, segmentIndex) as any;
+    if (!row) return null;
+    return {
+      stream: String(row.stream),
+      segment_index: Number(row.segment_index),
+      object_key: String(row.object_key),
+      plan_generation: Number(row.plan_generation),
+      sections_json: String(row.sections_json),
+      section_sizes_json: String(row.section_sizes_json ?? "{}"),
+      size_bytes: Number(row.size_bytes ?? 0),
+      primary_timestamp_min_ms: row.primary_timestamp_min_ms == null ? null : this.toBigInt(row.primary_timestamp_min_ms),
+      primary_timestamp_max_ms: row.primary_timestamp_max_ms == null ? null : this.toBigInt(row.primary_timestamp_max_ms),
+      updated_at_ms: this.toBigInt(row.updated_at_ms),
+    };
+  }
+
+  upsertSearchSegmentCompanion(
+    stream: string,
+    segmentIndex: number,
+    objectKey: string,
+    planGeneration: number,
+    sectionsJson: string,
+    sectionSizesJson: string,
+    sizeBytes: number,
+    primaryTimestampMinMs: bigint | null,
+    primaryTimestampMaxMs: bigint | null
+  ): void {
+    this.stmts.upsertSearchSegmentCompanion.run(
+      stream,
+      segmentIndex,
+      objectKey,
+      planGeneration,
+      sectionsJson,
+      sectionSizesJson,
+      sizeBytes,
+      primaryTimestampMinMs,
+      primaryTimestampMaxMs,
+      this.nowMs()
+    );
+  }
+
+  deleteSearchSegmentCompanionsBeforeGeneration(stream: string, generation: number): void {
+    this.stmts.deleteSearchSegmentCompanionsFromGeneration.run(stream, generation);
+  }
+
+  deleteSearchSegmentCompanionsFrom(stream: string, segmentIndex: number): void {
+    this.stmts.deleteSearchSegmentCompanionsFromIndex.run(stream, segmentIndex);
+  }
+
+  deleteSearchSegmentCompanions(stream: string): void {
+    this.stmts.deleteSearchSegmentCompanions.run(stream);
+  }
+
+  commitManifest(
+    stream: string,
+    generation: number,
+    etag: string,
+    uploadedAtMs: bigint,
+    uploadedThrough: bigint,
+    sizeBytes: number
+  ): void {
+    const tx = this.db.transaction(() => {
+      this.stmts.upsertManifest.run(stream, generation, generation, uploadedAtMs, etag, sizeBytes);
+      this.stmts.advanceUploadedThrough.run(uploadedThrough, this.nowMs(), stream);
+      let gcThrough = uploadedThrough;
+      const touchState = this.touch.getStreamTouchState(stream);
+      if (touchState) {
+        const processedThrough = touchState.processed_through;
+        gcThrough = processedThrough < gcThrough ? processedThrough : gcThrough;
+      }
+      if (gcThrough < 0n) return;
+
+      const { deletedRows: rows, deletedBytes: bytes } = this.deleteWalThroughWithStats(stream, gcThrough, {
+        maxRows: BASE_WAL_GC_CHUNK_OFFSETS,
+      });
+      if (rows <= 0n) return;
+
+      // Keep retained-WAL counters consistent for metrics/debugging.
+      const now = this.nowMs();
+      this.db.query(
+        `UPDATE streams
+         SET wal_bytes = CASE WHEN wal_bytes >= ? THEN wal_bytes - ? ELSE 0 END,
+             wal_rows = CASE WHEN wal_rows >= ? THEN wal_rows - ? ELSE 0 END,
+             updated_at_ms = ?
+         WHERE stream = ?;`
+      ).run(bytes, bytes, rows, rows, now, stream);
+    });
+    tx();
+  }
+
+  recordObjectStoreRequestByHash(streamHash: string, artifact: string, op: string, bytes = 0, count = 1): void {
+    if (!streamHash || !artifact || !op) return;
+    this.stmts.recordObjectStoreRequest.run(streamHash, artifact, op, count, bytes, this.nowMs());
+  }
+
+  getObjectStoreRequestSummaryByHash(streamHash: string): ObjectStoreRequestSummary {
+    const rows = this.db
+      .query(
+        `SELECT artifact, op, count
+         FROM objectstore_request_counts
+         WHERE stream_hash=?
+         ORDER BY artifact ASC, op ASC;`
+      )
+      .all(streamHash) as any[];
+    return summarizeObjectStoreRequestCounts(
+      rows.map(
+        (row): ObjectStoreRequestCountRow => ({
+          artifact: String(row.artifact),
+          op: String(row.op),
+          count: this.toBigInt(row.count ?? 0),
+        })
+      )
+    );
+  }
+
+  getUploadedSegmentBytes(stream: string): bigint {
+    const row = this.db
+      .query(`SELECT COALESCE(SUM(size_bytes), 0) as total FROM segments WHERE stream=? AND r2_etag IS NOT NULL;`)
+      .get(stream) as any;
+    return this.toBigInt(row?.total ?? 0);
+  }
+
+  getPendingSealedSegmentBytes(stream: string): bigint {
+    const row = this.db
+      .query(`SELECT COALESCE(SUM(size_bytes), 0) as total FROM segments WHERE stream=? AND uploaded_at_ms IS NULL;`)
+      .get(stream) as any;
+    return this.toBigInt(row?.total ?? 0);
+  }
+
+  getRoutingIndexStorage(stream: string): { object_count: number; bytes: bigint } {
+    const row = this.db
+      .query(`SELECT COUNT(*) as cnt, COALESCE(SUM(size_bytes), 0) as total FROM index_runs WHERE stream=?;`)
+      .get(stream) as any;
+    return {
+      object_count: Number(row?.cnt ?? 0),
+      bytes: this.toBigInt(row?.total ?? 0),
+    };
+  }
+
+  getSecondaryIndexStorage(stream: string): Array<{ index_name: string; object_count: number; bytes: bigint }> {
+    const rows = this.db
+      .query(
+        `SELECT index_name, COUNT(*) as cnt, COALESCE(SUM(size_bytes), 0) as total
+         FROM secondary_index_runs
+         WHERE stream=?
+         GROUP BY index_name
+         ORDER BY index_name ASC;`
+      )
+      .all(stream) as any[];
+    return rows.map((row) => ({
+      index_name: String(row.index_name),
+      object_count: Number(row.cnt ?? 0),
+      bytes: this.toBigInt(row.total ?? 0),
+    }));
+  }
+
+  getLexiconIndexStorage(
+    stream: string
+  ): Array<{ source_kind: string; source_name: string; object_count: number; bytes: bigint }> {
+    const rows = this.db
+      .query(
+        `SELECT source_kind, source_name, COUNT(*) as cnt, COALESCE(SUM(size_bytes), 0) as total
+         FROM lexicon_index_runs
+         WHERE stream=?
+         GROUP BY source_kind, source_name
+         ORDER BY source_kind ASC, source_name ASC;`
+      )
+      .all(stream) as any[];
+    return rows.map((row) => ({
+      source_kind: String(row.source_kind),
+      source_name: String(row.source_name),
+      object_count: Number(row.cnt ?? 0),
+      bytes: this.toBigInt(row.total ?? 0),
+    }));
+  }
+
+  getBundledCompanionStorage(stream: string): { object_count: number; bytes: bigint } {
+    const row = this.db
+      .query(`SELECT COUNT(*) as cnt, COALESCE(SUM(size_bytes), 0) as total FROM search_segment_companions WHERE stream=?;`)
+      .get(stream) as any;
+    return {
+      object_count: Number(row?.cnt ?? 0),
+      bytes: this.toBigInt(row?.total ?? 0),
+    };
+  }
+
+  getSegmentLastAppendMsFromMeta(stream: string, segmentIndex: number): bigint | null {
+    const meta = this.getSegmentMeta(stream);
+    if (!meta) return null;
+    if (segmentIndex < 0 || segmentIndex >= meta.segment_count) return null;
+    const off = segmentIndex * 8;
+    if (off + 8 > meta.segment_last_ts.byteLength) return null;
+    const dv = new DataView(meta.segment_last_ts.buffer, meta.segment_last_ts.byteOffset, meta.segment_last_ts.byteLength);
+    return dv.getBigUint64(off, true) / 1_000_000n;
+  }
+
+  getFullModeDetailsSnapshot(request: FullModeDetailsSnapshotRequest): FullModeDetailsSnapshot {
+    const stream = request.stream;
+    const segmentCount = this.countSegmentsForStream(stream);
+    const uploadedSegmentCount = this.countUploadedSegments(stream);
+    return {
+      segmentCount,
+      uploadedSegmentCount,
+      manifest: this.getManifestRow(stream),
+      schemaRow: this.getSchemaRegistry(stream),
+      uploadedSegmentBytes: this.getUploadedSegmentBytes(stream),
+      pendingSealedSegmentBytes: this.getPendingSealedSegmentBytes(stream),
+      routingIndexStorage: this.getRoutingIndexStorage(stream),
+      secondaryIndexStorage: this.getSecondaryIndexStorage(stream),
+      lexiconIndexStorage: this.getLexiconIndexStorage(stream),
+      bundledCompanionStorage: this.getBundledCompanionStorage(stream),
+      routingState: this.getIndexState(stream),
+      routingRuns: this.listIndexRuns(stream),
+      retiredRoutingRuns: this.listRetiredIndexRuns(stream),
+      exactIndexes: request.exactIndexNames.map((indexName) => ({
+        indexName,
+        state: this.getSecondaryIndexState(stream, indexName),
+        activeRuns: this.listSecondaryIndexRuns(stream, indexName),
+        retiredRuns: this.listRetiredSecondaryIndexRuns(stream, indexName),
+      })),
+      routingLexiconState: this.getLexiconIndexState(stream, "routing_key", ""),
+      routingLexiconRuns: this.listLexiconIndexRuns(stream, "routing_key", ""),
+      retiredRoutingLexiconRuns: this.listRetiredLexiconIndexRuns(stream, "routing_key", ""),
+      companionPlan: this.getSearchCompanionPlan(stream),
+      companionRows: this.listSearchSegmentCompanions(stream),
+    };
+  }
+
+  getFullModeLagSnapshot(request: FullModeLagSnapshotRequest): Map<number, bigint> {
+    const out = new Map<number, bigint>();
+    const sorted = Array.from(new Set(request.segmentIndexes.filter((index) => Number.isInteger(index) && index >= 0))).sort((a, b) => a - b);
+    for (const index of sorted) {
+      const lastAppendMs = this.getSegmentLastAppendMsFromMeta(request.stream, index);
+      if (lastAppendMs != null) out.set(index, lastAppendMs);
+    }
+    return out;
+  }
+
+  /** Find candidates by bytes/rows/interval. */
+  candidates(
+    minPendingBytes: bigint,
+    minPendingRows: bigint,
+    maxIntervalMs: bigint,
+    limit: number
+  ): Array<{ stream: string; pending_bytes: bigint; pending_rows: bigint; last_segment_cut_ms: bigint; sealed_through: bigint; next_offset: bigint; epoch: number }> {
+    if (maxIntervalMs <= 0n) {
+      return this.stmts.candidateStreamsNoInterval.all(STREAM_FLAG_DELETED | STREAM_FLAG_TOUCH, minPendingBytes, minPendingRows, limit) as any;
+    }
+    const now = this.nowMs();
+    return this.stmts.candidateStreams.all(STREAM_FLAG_DELETED | STREAM_FLAG_TOUCH, minPendingBytes, minPendingRows, now, maxIntervalMs, limit) as any;
+  }
+}