@delali/sirannon-db 0.1.6 → 0.1.7

package/dist/client/index.mjs

@@ -9,13 +9,27 @@ var RemoteSubscriptionBuilderImpl = class {
     this.conditions = { ...this.conditions, ...conditions };
     return this;
   }
-  subscribe(callback) {
+  subscribe(callback, options) {
     const filter = Object.keys(this.conditions).length > 0 ? this.conditions : void 0;
-    return this.transport.subscribe(this.table, filter, callback);
+    return this.transport.subscribe(this.table, filter, callback, options);
+  }
+};
+
+// src/client/types.ts
+var RemoteError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RemoteError";
+    this.code = code;
   }
 };
 
 // src/client/database-proxy.ts
+var DEFAULT_LOAD_BATCH_SIZE = 1e3;
+function isAsyncIterable(value) {
+  return typeof value[Symbol.asyncIterator] === "function";
+}
 var RemoteDatabase = class {
   constructor(id, transport, onDispose) {
     this.id = id;
@@ -47,13 +61,96 @@ var RemoteDatabase = class {
    * Execute multiple statements as a single atomic transaction.
    * Returns an array of results, one per statement.
    *
-   * Requires HTTP transport. WebSocket transport does not
-   * support server-side transactions.
+   * The whole list travels in one request and commits or rolls back as a
+   * unit, so the client is never in the loop between statements.
    */
   async transaction(statements) {
     const response = await this.transport.transaction(statements);
     return response.results;
   }
+  /**
+   * Run the same statement once per parameter set as a single atomic
+   * transaction that commits with one fsync. Returns one result per
+   * parameter set, in order. Use this for a burst of same-shape writes
+   * (an import, a bulk insert) that must all commit or all roll back.
+   */
+  async batch(sql, paramsBatch, writeConcern) {
+    const response = await this.transport.batch(sql, paramsBatch, writeConcern);
+    return response.results;
+  }
+  /**
+   * Load a whole dataset through the same statement, batching it into requests
+   * for you and paying the one fsyncing WAL checkpoint once, after the final
+   * batch. The configured durability is restored after every batch, so an
+   * import that stops partway never leaves the writer at the relaxed level.
+   * Prefer this over {@link load} for anything larger than a single request:
+   * it runs the finalize itself, so there is no checkpoint flag to forget.
+   *
+   * Accepts a synchronous or asynchronous iterable of parameter sets, so rows
+   * can stream from a file or the network without being held in memory at
+   * once. Returns the total rows loaded and changes applied.
+   *
+   * ```ts
+   * const summary = await db.loadAll(
+   *   'INSERT INTO events (id, payload) VALUES (?, ?)',
+   *   rowStream,
+   *   { batchSize: 5000, durability: 'off' },
+   * )
+   * ```
+   */
+  async loadAll(sql, rows, options) {
+    const batchSize = options?.batchSize ?? DEFAULT_LOAD_BATCH_SIZE;
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+      throw new RemoteError("INVALID_ARGUMENT", "loadAll batchSize must be a positive integer");
+    }
+    const durability = options?.durability;
+    const total = { rowsLoaded: 0, changes: 0 };
+    const send = async (paramsBatch, checkpoint) => {
+      const summary = await this.transport.load(sql, paramsBatch, durability, checkpoint);
+      total.rowsLoaded += summary.rowsLoaded;
+      total.changes += summary.changes;
+    };
+    let batch = [];
+    let previous = null;
+    const rotate = async () => {
+      if (previous !== null) await send(previous, false);
+      previous = batch;
+      batch = [];
+    };
+    if (isAsyncIterable(rows)) {
+      for await (const row of rows) {
+        batch.push(row);
+        if (batch.length >= batchSize) await rotate();
+      }
+    } else {
+      for (const row of rows) {
+        batch.push(row);
+        if (batch.length >= batchSize) await rotate();
+      }
+    }
+    if (batch.length > 0) {
+      if (previous !== null) await send(previous, false);
+      await send(batch, true);
+    } else if (previous !== null) {
+      await send(previous, true);
+    }
+    return total;
+  }
+  /**
+   * Load one batch of rows through the same statement with writer durability
+   * relaxed for the duration, then restored before this resolves. This is the
+   * low-level primitive; prefer {@link loadAll} for a dataset that spans more
+   * than one request, since it runs the finalize itself rather than relying on
+   * a `checkpoint` flag.
+   *
+   * Returns the total rows loaded and changes applied. When splitting a dataset
+   * across many `load` calls by hand, pass `checkpoint: false` on every call
+   * but the last so the one fsyncing WAL checkpoint runs once at the end; the
+   * configured durability is restored after each call regardless.
+   */
+  async load(sql, paramsBatch, durability, checkpoint) {
+    return this.transport.load(sql, paramsBatch, durability, checkpoint);
+  }
   /**
    * Start building a CDC subscription for the given table.
    * Chain `.filter()` to narrow the events, then call `.subscribe()`
@@ -82,15 +179,99 @@ var RemoteDatabase = class {
   }
 };
 
-// src/client/types.ts
-var RemoteError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "RemoteError";
-    this.code = code;
+// src/core/cdc/encoding.ts
+var BLOB_TAG = "__sirannon_blob";
+var INT_TAG = "__sirannon_int";
+var SAFE_INT_BOUND = 9007199254740991n;
+var HEX_BYTES_RE = /^[0-9a-fA-F]*$/;
+var INT_PAYLOAD_RE = /^-?\d{1,19}$/;
+function encodeTaggedValues(value) {
+  if (typeof value === "bigint" || isBinaryValue(value)) {
+    return encodeTaggedLeaf(value);
+  }
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map(encodeTaggedValues);
+  }
+  if (typeof value.toJSON === "function") {
+    return value;
+  }
+  const obj = value;
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    out[k] = encodeTaggedValues(obj[k]);
+  }
+  return out;
+}
+function encodeTaggedLeaf(value) {
+  if (typeof value === "bigint") {
+    if (value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
+      return Number(value);
+    }
+    return { [INT_TAG]: value.toString() };
   }
-};
+  if (isBinaryValue(value)) {
+    return { [BLOB_TAG]: encodeHexBytes(value) };
+  }
+  return value;
+}
+function decodeTaggedValues(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (isBinaryValue(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map(decodeTaggedValues);
+  }
+  const obj = value;
+  const keys = Object.keys(obj);
+  if (keys.length === 1) {
+    const tag = keys[0];
+    const tagValue = obj[tag];
+    if (tag === BLOB_TAG && typeof tagValue === "string") {
+      return decodeHexBytes(tagValue);
+    }
+    if (tag === INT_TAG && typeof tagValue === "string") {
+      if (!INT_PAYLOAD_RE.test(tagValue)) {
+        throw new Error("Invalid tagged integer payload");
+      }
+      return BigInt(tagValue);
+    }
+  }
+  const out = {};
+  for (const k of keys) {
+    out[k] = decodeTaggedValues(obj[k]);
+  }
+  return out;
+}
+function isBinaryValue(value) {
+  return value instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(value);
+}
+function encodeHexBytes(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("hex").toUpperCase();
+  }
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex.toUpperCase();
+}
+function decodeHexBytes(hex) {
+  if (hex.length % 2 !== 0 || !HEX_BYTES_RE.test(hex)) {
+    throw new Error("Invalid CDC BLOB hex payload");
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(hex, "hex");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = Number.parseInt(hex.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Invalid CDC BLOB hex payload");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
 
 // src/client/transport/http.ts
 var HttpTransport = class {
@@ -105,13 +286,35 @@ var HttpTransport = class {
     };
   }
   async query(sql, params, readConcern) {
-    return this.post("/query", { sql, params, readConcern });
+    const response = await this.post("/query", {
+      sql,
+      params: encodeTaggedValues(params),
+      readConcern
+    });
+    return { rows: decodeTaggedValues(response.rows ?? []) };
   }
   async execute(sql, params) {
-    return this.post("/execute", { sql, params });
+    return this.post("/execute", { sql, params: encodeTaggedValues(params) });
   }
   async transaction(statements) {
-    return this.post("/transaction", { statements });
+    return this.post("/transaction", {
+      statements: statements.map((stmt) => ({ sql: stmt.sql, params: encodeTaggedValues(stmt.params) }))
+    });
+  }
+  async batch(sql, paramsBatch, writeConcern) {
+    return this.post("/batch", {
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      writeConcern
+    });
+  }
+  async load(sql, paramsBatch, durability, checkpoint) {
+    return this.post("/load", {
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      durability,
+      checkpoint
+    });
   }
   async subscribe(_table, _filter, _callback) {
     throw new RemoteError(
@@ -182,29 +385,76 @@ var WebSocketTransport = class {
   async query(sql, params) {
     await this.ensureConnected();
     const id = this.nextId();
-    return this.request({ type: "query", id, sql, params });
+    const response = await this.request({
+      type: "query",
+      id,
+      sql,
+      params: encodeTaggedValues(params)
+    });
+    return { rows: decodeTaggedValues(response.rows ?? []) };
   }
   async execute(sql, params) {
     await this.ensureConnected();
     const id = this.nextId();
-    return this.request({ type: "execute", id, sql, params });
+    return this.request({
+      type: "execute",
+      id,
+      sql,
+      params: encodeTaggedValues(params)
+    });
   }
-  async transaction(_statements) {
-    throw new RemoteError(
-      "TRANSPORT_ERROR",
-      "Transactions are not supported over WebSocket. Use HTTP transport for batch transactions."
-    );
+  async transaction(statements) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({
+      type: "transaction",
+      id,
+      statements: statements.map((stmt) => ({
+        sql: stmt.sql,
+        params: encodeTaggedValues(stmt.params)
+      }))
+    });
+  }
+  async batch(sql, paramsBatch, writeConcern) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({
+      type: "batch",
+      id,
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      ...writeConcern ? { writeConcern } : {}
+    });
   }
-  async subscribe(table, filter, callback) {
+  async load(sql, paramsBatch, durability, checkpoint) {
     await this.ensureConnected();
     const id = this.nextId();
-    this.activeSubscriptions.set(id, { table, filter, callback });
+    return this.request({
+      type: "load",
+      id,
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      ...durability ? { durability } : {},
+      ...checkpoint !== void 0 ? { checkpoint } : {}
+    });
+  }
+  async subscribe(table, filter, callback, options) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    this.activeSubscriptions.set(id, {
+      table,
+      filter,
+      callback,
+      onReset: options?.onReset,
+      lastSeq: void 0,
+      epoch: void 0
+    });
     try {
       const msg = {
         type: "subscribe",
         id,
         table,
-        ...filter ? { filter } : {}
+        ...filter ? { filter: encodeTaggedValues(filter) } : {}
       };
       await this.request(msg);
     } catch (err) {
@@ -303,6 +553,29 @@ var WebSocketTransport = class {
         break;
       }
       case "subscribed": {
+        const sub = this.activeSubscriptions.get(msg.id);
+        if (sub) {
+          if (msg.epoch !== void 0) {
+            sub.epoch = msg.epoch;
+          }
+          let baseline;
+          if (msg.seq !== void 0) {
+            try {
+              baseline = BigInt(msg.seq);
+            } catch {
+              baseline = void 0;
+            }
+          }
+          if (msg.resync) {
+            sub.lastSeq = baseline;
+            try {
+              sub.onReset?.();
+            } catch {
+            }
+          } else if (sub.lastSeq === void 0 && baseline !== void 0) {
+            sub.lastSeq = baseline;
+          }
+        }
         const pending = this.pendingRequests.get(msg.id);
         if (pending) {
           clearTimeout(pending.timer);
@@ -327,11 +600,14 @@ var WebSocketTransport = class {
             const event = {
               type: msg.event.type,
               table: msg.event.table,
-              row: msg.event.row,
-              oldRow: msg.event.oldRow,
+              row: decodeTaggedValues(msg.event.row),
+              oldRow: msg.event.oldRow === void 0 ? void 0 : decodeTaggedValues(msg.event.oldRow),
               seq: BigInt(msg.event.seq),
               timestamp: msg.event.timestamp
             };
+            if (sub.lastSeq === void 0 || event.seq > sub.lastSeq) {
+              sub.lastSeq = event.seq;
+            }
             sub.callback(event);
           } catch {
           }
@@ -372,7 +648,9 @@ var WebSocketTransport = class {
           type: "subscribe",
           id,
           table: sub.table,
-          ...sub.filter ? { filter: sub.filter } : {}
+          ...sub.filter ? { filter: encodeTaggedValues(sub.filter) } : {},
+          ...sub.lastSeq !== void 0 ? { sinceSeq: sub.lastSeq.toString() } : {},
+          ...sub.epoch !== void 0 ? { epoch: sub.epoch } : {}
         };
         await this.request(msg);
       } catch {
@@ -387,10 +665,10 @@ var WebSocketTransport = class {
         reject(new RemoteError("CONNECTION_ERROR", "WebSocket is not connected"));
         return;
       }
-      const timer = setTimeout(() => {
+      const timer = this.requestTimeout > 0 ? setTimeout(() => {
         this.pendingRequests.delete(id);
         reject(new RemoteError("TIMEOUT", `Request timed out after ${this.requestTimeout}ms`));
-      }, this.requestTimeout);
+      }, this.requestTimeout) : void 0;
       this.pendingRequests.set(id, {
         resolve,
         reject,
@@ -551,6 +829,7 @@ var SirannonClient = class {
   webSocketProtocols;
   autoReconnect;
   reconnectInterval;
+  requestTimeout;
   databases = /* @__PURE__ */ new Map();
   closed = false;
   topologyEnabled;
@@ -584,6 +863,7 @@ var SirannonClient = class {
       this.webSocketProtocols = topoOpts.webSocketProtocols;
       this.autoReconnect = topoOpts.autoReconnect ?? true;
       this.reconnectInterval = topoOpts.reconnectInterval ?? 1e3;
+      this.requestTimeout = topoOpts.requestTimeout;
     } else {
       this.topologyEnabled = false;
       this.primaryUrl = void 0;
@@ -599,6 +879,7 @@ var SirannonClient = class {
       this.webSocketProtocols = options?.webSocketProtocols;
       this.autoReconnect = options?.autoReconnect ?? true;
       this.reconnectInterval = options?.reconnectInterval ?? 1e3;
+      this.requestTimeout = options?.requestTimeout;
     }
   }
   database(id) {
@@ -640,7 +921,8 @@ var SirannonClient = class {
     return new WebSocketTransport(`${wsBaseUrl}/db/${encodedId}`, {
       autoReconnect: this.autoReconnect,
       reconnectInterval: this.reconnectInterval,
-      protocols: this.webSocketProtocols
+      protocols: this.webSocketProtocols,
+      requestTimeout: this.requestTimeout
     });
   }
   _createTransportForEndpoint(url, databaseId) {
@@ -915,9 +1197,35 @@ var TopologyAwareTransport = class {
       throw err;
     }
   }
-  async subscribe(table, filter, callback) {
+  async batch(sql, paramsBatch, writeConcern) {
+    const transport = await this.getWriteTransport();
+    try {
+      return await transport.batch(sql, paramsBatch, writeConcern);
+    } catch (err) {
+      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
+        await this.client._refreshClusterRouting(this.databaseId);
+        this.writeTransport = null;
+        this.currentWriteUrl = "";
+      }
+      throw err;
+    }
+  }
+  async load(sql, paramsBatch, durability, checkpoint) {
+    const transport = await this.getWriteTransport();
+    try {
+      return await transport.load(sql, paramsBatch, durability, checkpoint);
+    } catch (err) {
+      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
+        await this.client._refreshClusterRouting(this.databaseId);
+        this.writeTransport = null;
+        this.currentWriteUrl = "";
+      }
+      throw err;
+    }
+  }
+  async subscribe(table, filter, callback, options) {
     try {
-      return await this.subscribeOnCurrentEndpoint(table, filter, callback);
+      return await this.subscribeOnCurrentEndpoint(table, filter, callback, options);
     } catch (err) {
       if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
         const hadActiveSubscriptions = this.activeSubscriptions.size > 0;
@@ -928,7 +1236,7 @@ var TopologyAwareTransport = class {
         if (!hadActiveSubscriptions) {
           this.closeSubscriptionTransport();
         }
-        return this.subscribeOnCurrentEndpoint(table, filter, callback);
+        return this.subscribeOnCurrentEndpoint(table, filter, callback, options);
       }
       throw err;
     }
@@ -963,15 +1271,16 @@ var TopologyAwareTransport = class {
     this.currentSubscriptionUrl = "";
     this.client._unregisterTopologyTransport(this.databaseId, this);
   }
-  async subscribeOnCurrentEndpoint(table, filter, callback) {
+  async subscribeOnCurrentEndpoint(table, filter, callback, options) {
     return this.withSubscriptionOperation(async () => {
       const transport = await this.getSubscriptionTransport(this.client._getReadConcern());
-      const remote = await transport.subscribe(table, filter, callback);
+      const remote = await transport.subscribe(table, filter, callback, options);
       const subscription = {
         id: ++this.nextSubscriptionId,
         table,
         filter,
         callback,
+        onReset: options?.onReset,
         remote,
         active: true
       };
@@ -1006,7 +1315,9 @@ var TopologyAwareTransport = class {
     try {
       for (const subscription of subscriptions) {
         if (!subscription.active) continue;
-        const remote = await nextTransport.subscribe(subscription.table, subscription.filter, subscription.callback);
+        const remote = await nextTransport.subscribe(subscription.table, subscription.filter, subscription.callback, {
+          onReset: subscription.onReset
+        });
         if (!subscription.active) {
           remote.unsubscribe();
           continue;

package/dist/core/index.d.ts

@@ -1,15 +1,61 @@
-export { B as BackupManager, a as BackupScheduler } from '../index-CLdNrcPz.js';
-export { C as ChangeTracker, a as ChangeTrackerOptions } from '../change-tracker-CFTQ9TSn.js';
-import { S as SQLiteDriver, a as SQLiteConnection } from '../types-BFSsG77t.js';
-export { D as DriverCapabilities, O as OpenOptions, R as RunResult, b as SQLiteStatement } from '../types-BFSsG77t.js';
-import { D as Database } from '../database-BVY1GqE7.js';
-export { H as HookDispose, a as HookEvent, b as HookEventContextMap, c as HookHandler, d as HookRegistry, M as MetricsCollector, S as SubscribeHookContext } from '../database-BVY1GqE7.js';
-export { B as BackupError, C as CDCError, a as ConnectionPoolError, D as DatabaseAlreadyExistsError, b as DatabaseNotFoundError, E as ExtensionError, H as HookDeniedError, M as MaxDatabasesError, c as MigrationError, Q as QueryError, R as ReadOnlyError, S as SirannonError, T as TransactionError } from '../errors-C00ed08Q.js';
-import { D as DatabaseOptions, L as LifecycleConfig, P as Params, E as ExecuteResult } from '../types-D-74JiXb.js';
-export { A as AfterQueryHook, m as BackupScheduleOptions, a as BeforeConnectHook, B as BeforeQueryHook, g as BeforeSubscribeHook, j as CDCMetrics, C as ChangeEvent, n as ChangeOperation, o as ClientOptions, p as ClusterReadEndpointInfo, q as ClusterStatusInfo, f as ConnectionHookContext, i as ConnectionMetrics, r as CorsOptions, c as DatabaseCloseHook, b as DatabaseOpenHook, H as HookConfig, M as MetricsConfig, O as OnRequestHook, Q as QueryHookContext, h as QueryMetrics, k as QueryOptions, R as ReadConcern, s as ReadConcernLevel, t as ReplicationStatusInfo, u as RequestContext, v as RequestDenial, w as ServerExecutionTarget, x as ServerExecutionTargetResolver, d as ServerOptions, S as SirannonOptions, y as Subscription, l as SubscriptionBuilder, T as Transaction, e as WSHandlerOptions, W as WriteConcern, z as WriteConcernLevel } from '../types-D-74JiXb.js';
-import { M as Migration, a as MigrationResult, R as RollbackResult } from '../types-BeozgNPr.js';
-export { A as AppliedMigration, b as AppliedMigrationEntry } from '../types-BeozgNPr.js';
-export { S as Sirannon } from '../sirannon-Cd-lK6T0.js';
+import { g as BulkLoadDurability, e as SQLiteConnection, s as SynchronousLevel, h as BulkLoadResult, a as SQLiteDriver, t as WorkerHostOptions, D as DatabaseOptions, L as LifecycleConfig, P as Params, E as ExecuteResult } from '../types-D_hQW1hr.js';
+export { A as AfterQueryHook, f as BackupScheduleOptions, u as BatchSummary, b as BeforeConnectHook, B as BeforeQueryHook, l as BeforeSubscribeHook, q as BulkLoadOptions, o as CDCMetrics, C as ChangeEvent, v as ChangeOperation, w as ClientOptions, x as ClusterReadEndpointInfo, y as ClusterStatusInfo, k as ConnectionHookContext, n as ConnectionMetrics, z as CorsOptions, d as DatabaseCloseHook, c as DatabaseOpenHook, F as DriverCapabilities, G as DriverWorkerEntry, H as HookConfig, M as MetricsConfig, O as OnRequestHook, I as OpenOptions, Q as QueryHookContext, m as QueryMetrics, p as QueryOptions, R as ReadConcern, J as ReadConcernLevel, K as ReplicationStatusInfo, N as RequestContext, U as RequestDenial, V as RunResult, X as SQLiteStatement, Y as ServerExecutionTarget, Z as ServerExecutionTargetResolver, i as ServerOptions, S as SirannonOptions, _ as Subscription, r as SubscriptionBuilder, T as Transaction, j as WSHandlerOptions, W as WriteConcern, $ as WriteConcernLevel, a0 as WriterWorkerOptions } from '../types-D_hQW1hr.js';
+export { C as ChangeTracker, a as ChangeTrackerOptions } from '../change-tracker-CbmaMO-N.js';
+import { D as Database } from '../database-DuGp0Rtr.js';
+export { H as HookDispose, a as HookEvent, b as HookEventContextMap, c as HookHandler, d as HookRegistry, M as MetricsCollector, S as SubscribeHookContext } from '../database-DuGp0Rtr.js';
+export { B as BackupError, C as CDCError, a as ConnectionPoolError, D as DatabaseAlreadyExistsError, b as DatabaseNotFoundError, E as ExtensionError, F as ForbiddenSqlError, H as HookDeniedError, M as MaxDatabasesError, c as MigrationError, Q as QueryError, R as ReadOnlyError, S as SirannonError, T as TransactionError, W as WriteOverloadError } from '../errors-5Nf5ZAEC.js';
+import { M as Migration, a as MigrationResult, R as RollbackResult } from '../types-D4p4UyDK.js';
+export { A as AppliedMigration, b as AppliedMigrationEntry } from '../types-D4p4UyDK.js';
+export { S as Sirannon } from '../sirannon-4SspRvP5.js';
+
+declare function isBulkLoadDurability(value: unknown): value is BulkLoadDurability;
+interface BulkLoadRun {
+    writer: SQLiteConnection;
+    configuredSynchronous: SynchronousLevel;
+    walMode: boolean;
+    durability: BulkLoadDurability | undefined;
+    checkpoint?: boolean;
+    loadRows: () => Promise<BulkLoadResult>;
+}
+/**
+ * Run a bulk load with relaxed writer durability, then restore the
+ * operator-configured level. The caller must hold the database's writer lock
+ * for the whole call, so no other write commits under the relaxed level.
+ *
+ * Interruption safety, by failure mode:
+ * - A load statement fails: the surrounding transaction rolls back, the
+ *   configured level is restored, and the database is exactly as it was before
+ *   the load; the operator recovers by re-running the load.
+ * - The process crashes mid-load: `PRAGMA synchronous` is connection state
+ *   that SQLite never stores in the database file, so the next open re-applies
+ *   the configured level, and the uncommitted transaction rolls back from the
+ *   WAL on open.
+ * - Power loss or an OS crash during a load at 'off': SQLite documents that
+ *   the file may be corrupted, which is why 'off' fits only a load the
+ *   operator can re-run from scratch; 'normal' keeps WAL corruption safety.
+ *
+ * The restore runs on both the success and the failure path. A restore pragma
+ * only fails when the writer connection itself is gone, so on a committed load
+ * that failure is reported as 'DURABILITY_RESTORE_FAILED', which tells the
+ * operator the load committed and must not be re-run; on a failed load the
+ * original load error stays dominant.
+ *
+ * On success, and only when the load changed rows, the WAL is checkpointed
+ * after the restore so the loaded pages are written into the main database
+ * file and fsync'd at the restored synchronous level. A reader holding the WAL
+ * can defer that transfer: the checkpoint retries a few times and then leaves
+ * the remaining pages for a later checkpoint rather than failing a load that
+ * has already committed, so those pages stay in the WAL until then. The
+ * checkpoint runs synchronously in the engine and blocks the event loop for
+ * the flush, which grows with the size of the load.
+ *
+ * A multi-batch import passes `checkpoint: false` on every load but the last so
+ * the one fsyncing checkpoint is paid once at the end instead of once per
+ * batch; each intermediate load still restores the configured level, and
+ * SQLite's automatic checkpoint keeps the WAL bounded during the import at the
+ * relaxed level with no fsync of its own.
+ */
+declare function runBulkLoad(run: BulkLoadRun): Promise<BulkLoadResult>;
 
 interface ConnectionPoolOptions {
     driver: SQLiteDriver;
@@ -17,6 +63,9 @@ interface ConnectionPoolOptions {
     readOnly?: boolean;
     readPoolSize?: number;
     walMode?: boolean;
+    synchronous?: SynchronousLevel;
+    useWriterWorker?: boolean;
+    workerHostOptions?: WorkerHostOptions;
 }
 declare class ConnectionPool {
     private readonly writer;
@@ -34,6 +83,14 @@ declare class ConnectionPool {
 
 declare function defineDriver(config: SQLiteDriver): SQLiteDriver;
 
+declare const DEFAULT_SYNCHRONOUS: SynchronousLevel;
+/**
+ * Map a synchronous level to its PRAGMA argument through an allowlist, so a
+ * value smuggled past the type system can never reach SQL interpolation.
+ */
+declare function synchronousPragmaValue(level: SynchronousLevel | undefined): string;
+declare function isSynchronousLevel(value: unknown): value is SynchronousLevel;
+
 interface LifecycleCallbacks {
     open: (id: string, path: string, options?: DatabaseOptions) => Promise<Database>;
     close: (id: string) => Promise<void>;
@@ -83,4 +140,4 @@ declare function queryOne<T = Record<string, unknown>>(conn: SQLiteConnection, s
 declare function execute(conn: SQLiteConnection, sql: string, params?: Params): Promise<ExecuteResult>;
 declare function executeBatch(conn: SQLiteConnection, sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
 
-export { ConnectionPool, type ConnectionPoolOptions, Database, DatabaseOptions, ExecuteResult, type LifecycleCallbacks, LifecycleConfig, LifecycleManager, Migration, MigrationResult, MigrationRunner, Params, RollbackResult, SQLiteConnection, SQLiteDriver, type TenantResolverOptions, createTenantResolver, defineDriver, execute, executeBatch, query, queryOne, sanitizeTenantId, tenantPath };
+export { BulkLoadDurability, BulkLoadResult, ConnectionPool, type ConnectionPoolOptions, DEFAULT_SYNCHRONOUS, Database, DatabaseOptions, ExecuteResult, type LifecycleCallbacks, LifecycleConfig, LifecycleManager, Migration, MigrationResult, MigrationRunner, Params, RollbackResult, SQLiteConnection, SQLiteDriver, SynchronousLevel, type TenantResolverOptions, createTenantResolver, defineDriver, execute, executeBatch, isBulkLoadDurability, isSynchronousLevel, query, queryOne, runBulkLoad, sanitizeTenantId, synchronousPragmaValue, tenantPath };