@delali/sirannon-db 0.1.6 → 0.1.8

package/dist/{chunk-UTO3ZAFS.mjs → chunk-HHRMRFFR.mjs}

@@ -1,11 +1,67 @@
-import { decodeTaggedValues, SAFE_INT_BOUND_TEXT } from './chunk-GS7T5YMI.mjs';
-import { CDCError } from './chunk-O7BHI3CF.mjs';
+import { synchronousPragmaValue } from './chunk-CJLYFDP5.mjs';
+import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, CDC_TRIGGER_PREFIX, SAFE_INT_BOUND_TEXT } from './chunk-GEZUUIKV.mjs';
+import { SirannonError, ForbiddenSqlError, CDCError } from './chunk-YPYVQJ4C.mjs';
+
+// src/core/bulk-load.ts
+var DEFAULT_LOAD_DURABILITY = "off";
+var CHECKPOINT_ATTEMPTS = 3;
+var CHECKPOINT_RETRY_DELAY_MS = 50;
+function isBulkLoadDurability(value) {
+  return value === "off" || value === "normal";
+}
+async function runBulkLoad(run) {
+  const durability = run.durability ?? DEFAULT_LOAD_DURABILITY;
+  if (!isBulkLoadDurability(durability)) {
+    throw new SirannonError("Bulk load durability must be 'off' or 'normal'", "INVALID_DURABILITY");
+  }
+  const restorePragma = `PRAGMA synchronous = ${synchronousPragmaValue(run.configuredSynchronous)}`;
+  await run.writer.exec(`PRAGMA synchronous = ${synchronousPragmaValue(durability)}`);
+  let result;
+  let loadError;
+  try {
+    result = await run.loadRows();
+  } catch (err) {
+    loadError = err;
+  }
+  try {
+    await run.writer.exec(restorePragma);
+  } catch {
+    if (loadError !== void 0) throw loadError;
+    throw new SirannonError(
+      "Bulk load committed but durability could not be restored because the writer connection failed",
+      "DURABILITY_RESTORE_FAILED"
+    );
+  }
+  if (loadError !== void 0) {
+    throw loadError;
+  }
+  if (result === void 0) {
+    throw new SirannonError("Bulk load completed without a result", "INTERNAL_ERROR");
+  }
+  if ((run.checkpoint ?? true) && run.walMode && result.changes > 0) {
+    await checkpoint(run.writer);
+  }
+  return result;
+}
+async function checkpoint(writer) {
+  for (let attempt = 0; attempt < CHECKPOINT_ATTEMPTS; attempt++) {
+    if (attempt > 0) {
+      await delay(attempt * CHECKPOINT_RETRY_DELAY_MS);
+    }
+    const stmt = await writer.prepare("PRAGMA wal_checkpoint(TRUNCATE)");
+    const row = await stmt.get();
+    if (!row || row.busy === 0) return;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/core/cdc/trigger-sql.ts
 async function dropCdcTriggers(conn, table) {
-  await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_insert"`);
-  await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_update"`);
-  await conn.exec(`DROP TRIGGER IF EXISTS "_sirannon_trg_${table}_delete"`);
+  await conn.exec(`DROP TRIGGER IF EXISTS "${CDC_TRIGGER_PREFIX}${table}_insert"`);
+  await conn.exec(`DROP TRIGGER IF EXISTS "${CDC_TRIGGER_PREFIX}${table}_update"`);
+  await conn.exec(`DROP TRIGGER IF EXISTS "${CDC_TRIGGER_PREFIX}${table}_delete"`);
 }
 async function installCdcTriggers(conn, changesTable, table, columns, pkColumns, replication) {
   const newJson = buildJsonObject(columns, "NEW");
@@ -15,7 +71,7 @@ async function installCdcTriggers(conn, changesTable, table, columns, pkColumns,
   const replCols = replication ? ", node_id, tx_id, hlc" : "";
   const replVals = replication ? ", '', '', ''" : "";
   await conn.exec(`
-			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_insert"
+			CREATE TRIGGER IF NOT EXISTS "${CDC_TRIGGER_PREFIX}${table}_insert"
 			AFTER INSERT ON "${table}"
 			BEGIN
 				INSERT INTO "${changesTable}" (table_name, operation, row_id, new_data${replCols})
@@ -23,7 +79,7 @@ async function installCdcTriggers(conn, changesTable, table, columns, pkColumns,
 			END
 		`);
   await conn.exec(`
-			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_update"
+			CREATE TRIGGER IF NOT EXISTS "${CDC_TRIGGER_PREFIX}${table}_update"
 			AFTER UPDATE ON "${table}"
 			BEGIN
 				INSERT INTO "${changesTable}" (table_name, operation, row_id, old_data, new_data${replCols})
@@ -31,7 +87,7 @@ async function installCdcTriggers(conn, changesTable, table, columns, pkColumns,
 			END
 		`);
   await conn.exec(`
-			CREATE TRIGGER IF NOT EXISTS "_sirannon_trg_${table}_delete"
+			CREATE TRIGGER IF NOT EXISTS "${CDC_TRIGGER_PREFIX}${table}_delete"
 			AFTER DELETE ON "${table}"
 			BEGIN
 				INSERT INTO "${changesTable}" (table_name, operation, row_id, old_data${replCols})
@@ -64,7 +120,6 @@ function escStr(name) {
 
 // src/core/cdc/change-tracker.ts
 var DEFAULT_RETENTION_MS = 36e5;
-var DEFAULT_CHANGES_TABLE = "_sirannon_changes";
 var DEFAULT_POLL_BATCH_SIZE = 1e3;
 var IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var ChangeTracker = class {
@@ -80,13 +135,16 @@ var ChangeTracker = class {
   pruneBoundary = null;
   constructor(options) {
     this.retentionMs = options?.retention ?? DEFAULT_RETENTION_MS;
-    this.changesTable = options?.changesTable ?? DEFAULT_CHANGES_TABLE;
+    this.changesTable = options?.changesTable ?? CHANGES_TABLE;
     this.pollBatchSize = options?.pollBatchSize ?? DEFAULT_POLL_BATCH_SIZE;
     this.replication = options?.replication ?? false;
     this.assertIdentifier(this.changesTable, "changes table name");
   }
   async watch(conn, table) {
     this.assertIdentifier(table, "table name");
+    if (isReservedIdentifier(table)) {
+      throw new ForbiddenSqlError(`Table '${table}' is reserved for Sirannon and cannot be watched`);
+    }
     await this.ensureChangesTable(conn);
     const columns = await this.getColumns(conn, table);
     if (columns.length === 0) {
@@ -226,20 +284,64 @@ var ChangeTracker = class {
     if (rows.length === 0) {
       return [];
     }
-    const events = [];
-    for (const row of rows) {
-      events.push({
-        type: row.operation.toLowerCase(),
-        table: row.table_name,
-        row: row.new_data ? decodeTaggedValues(JSON.parse(row.new_data)) : {},
-        oldRow: row.old_data ? decodeTaggedValues(JSON.parse(row.old_data)) : void 0,
-        seq: BigInt(row.seq),
-        timestamp: row.changed_at
-      });
-    }
+    const events = rows.map((row) => this.rowToEvent(row));
     this.lastSeq = BigInt(rows[rows.length - 1].seq);
     return events;
   }
+  /** The highest seq already polled; live subscribers receive events beyond it. */
+  get cursor() {
+    return this.lastSeq;
+  }
+  /**
+   * Reads retained changes for one table with seq in `(afterSeq, upToSeq]`,
+   * ordered ascending and capped at `limit`. Used to replay history to a
+   * resuming subscriber without disturbing the shared poll cursor.
+   */
+  async readSince(conn, table, afterSeq, upToSeq, limit) {
+    if (!this.changesTableReady) {
+      await this.detectChangesTable(conn);
+      if (!this.changesTableReady) {
+        return [];
+      }
+    }
+    const stmt = await this.getStmt(
+      conn,
+      "read_since",
+      `SELECT seq, table_name, operation, row_id, changed_at, old_data, new_data
+			 FROM "${this.changesTable}"
+			 WHERE table_name = ? AND seq > ? AND seq <= ?
+			 ORDER BY seq ASC
+			 LIMIT ?`
+    );
+    const rows = await stmt.all(table, afterSeq.toString(), upToSeq.toString(), limit);
+    return rows.map((row) => this.rowToEvent(row));
+  }
+  /** The lowest retained seq, or `null` when the change log is empty. */
+  async getMinSeq(conn) {
+    if (!this.changesTableReady) {
+      await this.detectChangesTable(conn);
+      if (!this.changesTableReady) {
+        return null;
+      }
+    }
+    const stmt = await this.getStmt(conn, "min_seq", `SELECT MIN(seq) AS seq FROM "${this.changesTable}"`);
+    const row = await stmt.get();
+    const seq = row?.seq;
+    if (seq === void 0 || seq === null) {
+      return null;
+    }
+    return typeof seq === "bigint" ? seq : BigInt(String(seq));
+  }
+  rowToEvent(row) {
+    return {
+      type: row.operation.toLowerCase(),
+      table: row.table_name,
+      row: row.new_data ? decodeTaggedValues(JSON.parse(row.new_data)) : {},
+      oldRow: row.old_data ? decodeTaggedValues(JSON.parse(row.old_data)) : void 0,
+      seq: BigInt(row.seq),
+      timestamp: row.changed_at
+    };
+  }
   async advanceToLatest(conn) {
     if (!this.changesTableReady) {
       await this.detectChangesTable(conn);
@@ -430,7 +532,7 @@ var SubscriptionManager = class {
       for (const id of ids) {
         const sub = this.subscriptions.get(id);
         if (!sub) continue;
-        if (sub.filter && !matchesFilter(event, sub.filter)) {
+        if (sub.filter && !changeMatchesFilter(event, sub.filter)) {
           continue;
         }
         try {
@@ -461,18 +563,19 @@ var SubscriptionBuilderImpl = class {
     return this.manager.subscribe(this.table, this.conditions, callback);
   }
 };
-function startPolling(conn, tracker, manager, intervalMs, onError) {
+function startPolling(conn, tracker, manager, intervalMs, onError, runExclusive) {
   let consecutiveErrors = 0;
   let tickCount = 0;
   let polling = false;
   const MAX_CONSECUTIVE_ERRORS = 10;
   const CLEANUP_INTERVAL_TICKS = 100;
+  const exclusive = runExclusive ?? ((operation) => operation());
   const tick = async () => {
     if (manager.size === 0) return;
     if (polling) return;
     polling = true;
     try {
-      const events = await tracker.poll(conn);
+      const events = await exclusive(() => tracker.poll(conn));
       if (events.length > 0) {
         manager.dispatch(events);
       }
@@ -480,7 +583,7 @@ function startPolling(conn, tracker, manager, intervalMs, onError) {
       tickCount++;
       if (tickCount >= CLEANUP_INTERVAL_TICKS) {
         tickCount = 0;
-        await tracker.cleanup(conn);
+        await exclusive(() => tracker.cleanup(conn));
       }
     } catch (err) {
       consecutiveErrors++;
@@ -501,14 +604,31 @@ function startPolling(conn, tracker, manager, intervalMs, onError) {
   };
   return stop;
 }
-function matchesFilter(event, filter) {
+function changeMatchesFilter(event, filter) {
   const target = event.type === "delete" ? event.oldRow ?? {} : event.row;
   for (const [key, value] of Object.entries(filter)) {
-    if (target[key] !== value) {
+    if (!filterValueMatches(target[key], value)) {
       return false;
     }
   }
   return true;
 }
+function filterValueMatches(rowValue, filterValue) {
+  if (rowValue === filterValue) return true;
+  if (typeof rowValue === "bigint" && typeof filterValue === "number") {
+    return Number.isInteger(filterValue) && BigInt(filterValue) === rowValue;
+  }
+  if (typeof rowValue === "number" && typeof filterValue === "bigint") {
+    return Number.isInteger(rowValue) && BigInt(rowValue) === filterValue;
+  }
+  if (rowValue instanceof Uint8Array && filterValue instanceof Uint8Array) {
+    if (rowValue.byteLength !== filterValue.byteLength) return false;
+    for (let i = 0; i < rowValue.byteLength; i++) {
+      if (rowValue[i] !== filterValue[i]) return false;
+    }
+    return true;
+  }
+  return false;
+}
 
-export { ChangeTracker, SubscriptionBuilderImpl, SubscriptionManager, startPolling };
+export { ChangeTracker, SubscriptionBuilderImpl, SubscriptionManager, changeMatchesFilter, isBulkLoadDurability, runBulkLoad, startPolling };

package/dist/chunk-TKGHYWQ6.mjs

@@ -0,0 +1,35 @@
+import { query, execute, executeBatch } from './chunk-CW6S3WL5.mjs';
+
+// src/core/transaction.ts
+var Transaction = class _Transaction {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  _lastInsertRowId = 0;
+  async query(sql, params) {
+    return query(this.conn, sql, params);
+  }
+  async execute(sql, params) {
+    const result = await execute(this.conn, sql, params);
+    this._lastInsertRowId = result.lastInsertRowId;
+    return result;
+  }
+  async executeBatch(sql, paramsBatch) {
+    const results = await executeBatch(this.conn, sql, paramsBatch);
+    if (results.length > 0) {
+      this._lastInsertRowId = results[results.length - 1].lastInsertRowId;
+    }
+    return results;
+  }
+  get lastInsertRowId() {
+    return this._lastInsertRowId;
+  }
+  static async run(conn, fn) {
+    return conn.transaction(async (txConn) => {
+      const tx = new _Transaction(txConn);
+      return fn(tx);
+    });
+  }
+};
+
+export { Transaction };

package/dist/chunk-UXLAO6ZH.mjs

@@ -0,0 +1,352 @@
+import { WORKER_CANCELLED_CODE, deserializeError } from './chunk-4ISB7XMA.mjs';
+import { BackupManager, BackupScheduler } from './chunk-VLTICJOD.mjs';
+import { SirannonError } from './chunk-YPYVQJ4C.mjs';
+import { Worker } from 'worker_threads';
+import { existsSync } from 'fs';
+import { resolve, dirname, join, sep } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// src/core/driver/statement-cache.ts
+var STATEMENT_CACHE_CAPACITY = 128;
+function createStatementCache(prepare) {
+  const cache = /* @__PURE__ */ new Map();
+  return (sql) => {
+    const cached = cache.get(sql);
+    if (cached !== void 0) {
+      cache.delete(sql);
+      cache.set(sql, cached);
+      return cached;
+    }
+    const prepared = prepare(sql);
+    cache.set(sql, prepared);
+    if (cache.size > STATEMENT_CACHE_CAPACITY) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    return prepared;
+  };
+}
+
+// src/core/driver/values.ts
+var SAFE_INT_BOUND = 9007199254740991n;
+function narrowSafeBigInt(value) {
+  if (typeof value === "bigint" && value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
+    return Number(value);
+  }
+  return value;
+}
+function narrowRowIntegers(row) {
+  if (row === null || typeof row !== "object") return row;
+  const obj = row;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === "bigint" && value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
+      obj[key] = Number(value);
+    }
+  }
+  return row;
+}
+function narrowRowsIntegers(rows) {
+  for (const row of rows) {
+    narrowRowIntegers(row);
+  }
+  return rows;
+}
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new SirannonError(
+        "Could not locate the package root to spawn the writer worker",
+        "WRITER_WORKER_UNRESOLVED"
+      );
+    }
+    dir = parent;
+  }
+}
+function resolveWorkerScript() {
+  const selfPath = fileURLToPath(import.meta.url);
+  const root = findPackageRoot(dirname(selfPath));
+  const bootstrap = join(root, "src", "core", "worker", "dev-bootstrap.mjs");
+  const built = join(root, "dist", "core", "writer-worker.mjs");
+  const runningFromSource = selfPath.startsWith(`${join(root, "src")}${sep}`);
+  const preferred = runningFromSource ? bootstrap : built;
+  const fallback = runningFromSource ? built : bootstrap;
+  if (existsSync(preferred)) return { url: pathToFileURL(preferred), execArgv: [] };
+  if (existsSync(fallback)) return { url: pathToFileURL(fallback), execArgv: [] };
+  throw new SirannonError(
+    `Writer-worker script not found under '${root}'. Build the package or run from source.`,
+    "WRITER_WORKER_UNRESOLVED"
+  );
+}
+
+// src/core/worker/host.ts
+var DEFAULT_WRITE_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RESTARTS = 5;
+var CLOSE_GRACE_MS = 1e3;
+var WriterWorker = class _WriterWorker {
+  constructor(openRequest, timeoutMs, maxRestarts) {
+    this.openRequest = openRequest;
+    this.timeoutMs = timeoutMs;
+    this.maxRestarts = maxRestarts;
+    this.connection = this.makeConnection();
+  }
+  worker = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  ready = Promise.resolve();
+  starting = true;
+  closed = false;
+  fatal = null;
+  restarts = 0;
+  connection;
+  static async start(entry, path, options, workerOptions) {
+    const worker = new _WriterWorker(
+      { kind: "open", entry, path, options },
+      workerOptions?.writeTimeoutMs ?? DEFAULT_WRITE_TIMEOUT_MS,
+      workerOptions?.maxRestarts ?? DEFAULT_MAX_RESTARTS
+    );
+    worker.spawn();
+    try {
+      await worker.ready;
+    } catch (err) {
+      await worker.close();
+      throw err;
+    }
+    worker.starting = false;
+    return worker;
+  }
+  spawn() {
+    const script = resolveWorkerScript();
+    const worker = new Worker(script.url, { execArgv: script.execArgv });
+    this.worker = worker;
+    worker.on("message", (res) => {
+      if (this.worker === worker) this.onResponse(res);
+    });
+    worker.on("error", (err) => {
+      if (this.worker === worker) this.fault(err);
+    });
+    worker.on("exit", (code) => {
+      if (this.worker === worker && !this.closed) {
+        this.fault(new SirannonError(`Writer worker exited with code ${code}`, "WRITER_WORKER_EXIT"));
+      }
+    });
+    this.ready = this.send(this.openRequest).then(() => void 0);
+    this.ready.catch(() => {
+    });
+  }
+  onResponse(res) {
+    const entry = this.pending.get(res.id);
+    if (!entry) return;
+    this.pending.delete(res.id);
+    clearPendingTimers(entry);
+    if (res.ok) {
+      entry.resolve(res.value);
+      return;
+    }
+    if (res.error.code === WORKER_CANCELLED_CODE) {
+      entry.reject(
+        new SirannonError(
+          `The writer worker could not take this operation within ${this.timeoutMs}ms; it was not applied and is safe to retry`,
+          "WRITE_OVERLOADED"
+        )
+      );
+      return;
+    }
+    entry.reject(deserializeError(res.error));
+  }
+  rejectPending(id, err) {
+    const entry = this.pending.get(id);
+    if (!entry) return;
+    this.pending.delete(id);
+    clearPendingTimers(entry);
+    entry.reject(err);
+  }
+  unresponsiveError(waitedMs) {
+    return new SirannonError(
+      `Writer worker did not respond within ${waitedMs}ms; the operation's outcome is unknown`,
+      "WRITER_WORKER_TIMEOUT"
+    );
+  }
+  onDeadline(id) {
+    const entry = this.pending.get(id);
+    if (!entry) return;
+    const worker = this.worker;
+    if (!entry.cancellable || !worker) {
+      this.rejectPending(id, this.unresponsiveError(this.timeoutMs));
+      return;
+    }
+    try {
+      worker.postMessage({ kind: "cancel", id });
+    } catch {
+      this.rejectPending(id, this.unresponsiveError(this.timeoutMs));
+      return;
+    }
+    entry.graceTimer = setTimeout(() => {
+      this.rejectPending(id, this.unresponsiveError(this.timeoutMs * 2));
+    }, this.timeoutMs);
+    entry.graceTimer.unref?.();
+  }
+  fault(errLike) {
+    if (this.closed || this.fatal) return;
+    const err = errLike instanceof Error ? errLike : new SirannonError(String(errLike), "WRITER_WORKER_ERROR");
+    const dead = this.worker;
+    this.worker = null;
+    for (const entry of this.pending.values()) {
+      clearPendingTimers(entry);
+      entry.reject(err);
+    }
+    this.pending.clear();
+    dead?.terminate().catch(() => {
+    });
+    if (this.starting) {
+      this.fatal = err;
+      this.ready = Promise.reject(err);
+      this.ready.catch(() => {
+      });
+      return;
+    }
+    this.restarts++;
+    if (this.restarts > this.maxRestarts) {
+      this.fatal = new SirannonError(
+        `Writer worker failed ${this.restarts} times and will not restart: ${err.message}`,
+        "WRITER_WORKER_FATAL"
+      );
+      this.ready = Promise.reject(this.fatal);
+      this.ready.catch(() => {
+      });
+      return;
+    }
+    this.spawn();
+  }
+  send(request) {
+    const worker = this.worker;
+    if (!worker) {
+      return Promise.reject(
+        this.fatal ?? new SirannonError("Writer worker is unavailable", "WRITER_WORKER_UNAVAILABLE")
+      );
+    }
+    const id = this.nextId++;
+    const message = { ...request, id };
+    return new Promise((resolve2, reject) => {
+      let timer = null;
+      if (this.timeoutMs > 0) {
+        timer = setTimeout(() => this.onDeadline(id), this.timeoutMs);
+        timer.unref?.();
+      }
+      const cancellable = request.kind !== "open" && request.kind !== "close";
+      this.pending.set(id, { resolve: resolve2, reject, timer, graceTimer: null, cancellable });
+      try {
+        worker.postMessage(message);
+      } catch (err) {
+        this.pending.delete(id);
+        if (timer) clearTimeout(timer);
+        reject(
+          new SirannonError(
+            `Failed to hand work to the writer worker: ${err instanceof Error ? err.message : String(err)}`,
+            "WRITER_WORKER_POST_FAILED"
+          )
+        );
+      }
+    });
+  }
+  request(request) {
+    if (this.fatal) return Promise.reject(this.fatal);
+    if (this.closed) return Promise.reject(new SirannonError("Writer worker is closed", "WRITER_WORKER_CLOSED"));
+    return this.ready.then(() => this.send(request)).then((value) => {
+      this.restarts = 0;
+      return value;
+    });
+  }
+  makeConnection() {
+    const conn = {
+      exec: (sql) => this.request({ kind: "exec", sql }),
+      prepare: async (sql) => ({
+        all: (...params) => this.request({ kind: "all", sql, params }),
+        get: (...params) => this.request({ kind: "get", sql, params }),
+        run: (...params) => this.request({ kind: "run", sql, params }),
+        allRaw: (...params) => this.request({ kind: "allRaw", sql, params })
+      }),
+      runBatch: (sql, paramsBatch) => this.request({ kind: "runBatch", sql, paramsBatch }),
+      runBatchSummary: (sql, paramsBatch) => this.request({ kind: "runBatchSummary", sql, paramsBatch }),
+      runGroup: (units) => this.request({
+        kind: "runGroup",
+        units: units.map((unit) => ({
+          statements: unit.statements.map((statement) => ({
+            sql: statement.sql,
+            params: statement.params ? [...statement.params] : []
+          }))
+        }))
+      }),
+      transaction: async (fn) => {
+        await conn.exec("BEGIN");
+        try {
+          const result = await fn(conn);
+          await conn.exec("COMMIT");
+          return result;
+        } catch (err) {
+          try {
+            await conn.exec("ROLLBACK");
+          } catch {
+          }
+          throw err;
+        }
+      },
+      close: () => this.close()
+    };
+    return conn;
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const worker = this.worker;
+    if (worker) {
+      try {
+        await Promise.race([
+          this.send({ kind: "close" }),
+          new Promise((_, reject) => {
+            const timer = setTimeout(() => reject(new Error("close timed out")), CLOSE_GRACE_MS);
+            timer.unref?.();
+          })
+        ]);
+      } catch {
+      }
+      await worker.terminate().catch(() => {
+      });
+    }
+    this.worker = null;
+    for (const entry of this.pending.values()) {
+      clearPendingTimers(entry);
+      entry.reject(new SirannonError("Writer worker is closed", "WRITER_WORKER_CLOSED"));
+    }
+    this.pending.clear();
+  }
+};
+function clearPendingTimers(entry) {
+  if (entry.timer) clearTimeout(entry.timer);
+  if (entry.graceTimer) clearTimeout(entry.graceTimer);
+}
+function nodeWriterContext() {
+  const held = new AsyncLocalStorage();
+  return {
+    run: (operation) => held.run(true, operation),
+    isActive: () => held.getStore() === true,
+    exit: (operation) => held.exit(operation)
+  };
+}
+function nodeResolveExtensionPath(extensionPath) {
+  return resolve(extensionPath);
+}
+function nodeBackupEngine() {
+  const manager = new BackupManager();
+  const scheduler = new BackupScheduler(manager);
+  return {
+    backup: (conn, destPath) => manager.backup(conn, destPath),
+    schedule: (conn, options, runExclusive) => scheduler.schedule(conn, options, runExclusive)
+  };
+}
+
+export { WriterWorker, createStatementCache, narrowRowIntegers, narrowRowsIntegers, narrowSafeBigInt, nodeBackupEngine, nodeResolveExtensionPath, nodeWriterContext };