@delali/sirannon-db 0.2.3-next.29 → 0.2.3-next.30

package/dist/backup-scheduler/index.d.ts

@@ -1,4 +1,4 @@
-import { e as SQLiteConnection, f as BackupScheduleOptions } from '../types-CXoPBeDM.js';
+import { e as SQLiteConnection, f as BackupScheduleOptions } from '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 
 declare class BackupManager {

package/dist/{change-tracker-C2Z8UbI0.d.ts → change-tracker-rTXrPhQq.d.ts}

@@ -1,4 +1,4 @@
-import { e as SQLiteConnection } from './types-CXoPBeDM.js';
+import { e as SQLiteConnection } from './types-OGVLZjPS.js';
 import { C as ChangeEvent } from './query-types-BvkzxKQv.js';
 
 /**

package/dist/{chunk-UPKKSUPA.mjs → chunk-BD3XGHFC.mjs}

@@ -1,12 +1,22 @@
 import { BackupManager, BackupScheduler } from './chunk-VOYGMAU7.mjs';
 import { WORKER_CANCELLED_CODE, deserializeError } from './chunk-4ISB7XMA.mjs';
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { SirannonError, ExtensionError } from './chunk-PBRXXISQ.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/extension.ts
+async function loadThroughRuntime(extensionPath, load) {
+  try {
+    load();
+  } catch (err) {
+    if (err instanceof SirannonError) throw err;
+    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+  }
+}
+
 // src/core/driver/statement-cache.ts
 var STATEMENT_CACHE_CAPACITY = 128;
 function createStatementCache(prepare) {
@@ -102,6 +112,7 @@ var WriterWorker = class _WriterWorker {
   closed = false;
   fatal = null;
   restarts = 0;
+  loadedExtensions = [];
   connection;
   static async start(entry, path, options, workerOptions) {
     const worker = new _WriterWorker(
@@ -134,10 +145,15 @@ var WriterWorker = class _WriterWorker {
         this.fault(new SirannonError(`Writer worker exited with code ${code}`, "WRITER_WORKER_EXIT"));
       }
     });
-    this.ready = this.send(this.openRequest).then(() => void 0);
+    this.ready = this.send(this.openRequest).then(() => this.reloadExtensionsOntoRestartedConnection());
     this.ready.catch(() => {
     });
   }
+  async reloadExtensionsOntoRestartedConnection() {
+    for (const path of this.loadedExtensions) {
+      await this.send({ kind: "loadExtension", path });
+    }
+  }
   onResponse(res) {
     const entry = this.pending.get(res.id);
     if (!entry) return;
@@ -241,7 +257,7 @@ var WriterWorker = class _WriterWorker {
         timer = setTimeout(() => this.onDeadline(id), this.timeoutMs);
         timer.unref?.();
       }
-      const cancellable = request.kind !== "open" && request.kind !== "close";
+      const cancellable = request.kind !== "open" && request.kind !== "close" && request.kind !== "loadExtension";
       this.pending.set(id, { resolve: resolve2, reject, timer, graceTimer: null, cancellable });
       try {
         worker.postMessage(message);
@@ -286,6 +302,10 @@ var WriterWorker = class _WriterWorker {
           }))
         }))
       }),
+      loadExtension: async (extensionPath) => {
+        await this.request({ kind: "loadExtension", path: extensionPath });
+        if (!this.loadedExtensions.includes(extensionPath)) this.loadedExtensions.push(extensionPath);
+      },
       transaction: async (fn) => {
         await conn.exec("BEGIN");
         try {
@@ -354,4 +374,4 @@ function nodeBackupEngine() {
   };
 }
 
-export { WriterWorker, createStatementCache, narrowRowIntegers, narrowRowsIntegers, narrowSafeBigInt, nodeBackupEngine, nodeResolveExtensionPath, nodeWriterContext };
+export { WriterWorker, createStatementCache, loadThroughRuntime, narrowRowIntegers, narrowRowsIntegers, narrowSafeBigInt, nodeBackupEngine, nodeResolveExtensionPath, nodeWriterContext };

package/dist/{chunk-DVWQD3GF.mjs → chunk-GVYLZVUZ.mjs}

@@ -6,6 +6,15 @@ var SirannonError = class extends Error {
     this.name = "SirannonError";
   }
 };
+var ExtensionError = class extends SirannonError {
+  constructor(path, cause) {
+    super(
+      cause ? `Failed to load extension '${path}': ${cause}` : `Failed to load extension '${path}'`,
+      "EXTENSION_ERROR"
+    );
+    this.name = "ExtensionError";
+  }
+};
 
 // src/core/driver/define.ts
 function defineDriver(config) {
@@ -46,4 +55,4 @@ function synchronousPragmaValue(level) {
   return value;
 }
 
-export { defineDriver, synchronousPragmaValue };
+export { ExtensionError, SirannonError, defineDriver, synchronousPragmaValue };

package/dist/client/index.d.ts

@@ -1,15 +1,15 @@
 export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-B0np8JS3.js';
 import { C as ConflictResolver, R as ReplicationBatch } from '../types-CjhxcjhA.js';
 export { a as ConflictContext, b as ConflictResolution } from '../types-CjhxcjhA.js';
-import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-BVAFmguz.js';
-import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-CqTMYzQP.js';
-export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-CqTMYzQP.js';
+import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-Bc6WuuFf.js';
+import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-DkjHphzB.js';
+export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-DkjHphzB.js';
 import { a as LiveQuery, b as LiveQueryState, c as LiveUpdate } from '../types-BCejqzNA.js';
-import { e as DeviceSyncPort, D as Database } from '../database-DvSvONb-.js';
+import { e as DeviceSyncPort, D as Database } from '../database-DvURlr-n.js';
 import { C as ChangeEvent, P as Params, R as ReadConcern, W as WriteConcern } from '../query-types-BvkzxKQv.js';
-import { Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-CEBVo1tO.js';
+import { Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-BQMNEubg.js';
 import '../operation-registry-6qErmUT2.js';
-import '../types-CXoPBeDM.js';
+import '../types-OGVLZjPS.js';
 
 /**
  * @public

package/dist/client/topology.d.ts

@@ -1,11 +1,11 @@
 import { a as ReadConcernLevel } from '../query-types-BvkzxKQv.js';
-import { C as ClientOptions } from '../server-options-BVAFmguz.js';
-import { T as Transport, D as DatabaseClient } from '../client-base-CqTMYzQP.js';
+import { C as ClientOptions } from '../server-options-Bc6WuuFf.js';
+import { T as Transport, D as DatabaseClient } from '../client-base-DkjHphzB.js';
 import '../operation-registry-6qErmUT2.js';
 import '../types-CjhxcjhA.js';
-import '../types-CXoPBeDM.js';
+import '../types-OGVLZjPS.js';
 import '../types-BCejqzNA.js';
-import '../protocol-CEBVo1tO.js';
+import '../protocol-BQMNEubg.js';
 
 interface TopologyRouting {
     _getReadEndpoint(databaseId?: string, readConcern?: ReadConcernLevel): Promise<string>;

package/dist/{client-base-CqTMYzQP.d.ts → client-base-DkjHphzB.d.ts}

@@ -1,8 +1,8 @@
-import { B as BulkLoadDurability, a as BulkLoadResult, C as ClientOptions } from './server-options-BVAFmguz.js';
+import { B as BulkLoadDurability, a as BulkLoadResult, C as ClientOptions } from './server-options-Bc6WuuFf.js';
 import { R as ResultOp, a as LiveQuery } from './types-BCejqzNA.js';
 import { O as OperationRef, b as OperationArguments } from './operation-registry-6qErmUT2.js';
 import { P as Params, R as ReadConcern, W as WriteConcern, C as ChangeEvent, Q as QueryOptions } from './query-types-BvkzxKQv.js';
-import { Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse } from './protocol-CEBVo1tO.js';
+import { Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse } from './protocol-BQMNEubg.js';
 
 /**
  * Message a client raises when the server accepts no SQL over the network.

package/dist/core/index.d.ts

@@ -1,16 +1,16 @@
-import { e as SQLiteConnection, n as SynchronousLevel, a as SQLiteDriver, W as WorkerHostOptions, D as DatabaseOptions, L as LifecycleConfig, M as Migration, m as MigrationResult, R as RollbackResult } from '../types-CXoPBeDM.js';
-export { A as AfterQueryHook, o as AppliedMigration, p as AppliedMigrationEntry, f as BackupScheduleOptions, q as BatchSummary, b as BeforeConnectHook, B as BeforeQueryHook, h as BeforeSubscribeHook, l as CDCMetrics, r as ClusterReadEndpointInfo, C as ClusterStatusInfo, g as ConnectionHookContext, k as ConnectionMetrics, d as DatabaseCloseHook, c as DatabaseOpenHook, s as DriverCapabilities, t as DriverWorkerEntry, H as HookConfig, u as MIGRATION_NAME_RE, i as MetricsConfig, v as MigrationBaseline, w as MigrationSource, N as NodeHealth, x as NodeHealthReason, y as NodeHealthState, O as OpenOptions, Q as QueryHookContext, j as QueryMetrics, z as RunResult, E as SQLiteStatement, S as SirannonOptions, T as Transaction, F as WriterWorkerOptions } from '../types-CXoPBeDM.js';
-import { B as BulkLoadDurability, a as BulkLoadResult } from '../server-options-BVAFmguz.js';
-export { c as AuthenticateHook, b as BulkLoadOptions, C as ClientOptions, d as ClusterStatusAuthorizer, e as CorsOptions, R as ReplicationStatusInfo, f as RequestContext, g as ServerExecutionTarget, h as ServerExecutionTargetResolver, S as ServerOptions, W as WSHandlerOptions } from '../server-options-BVAFmguz.js';
-export { C as ChangeTracker, a as ChangeTrackerOptions } from '../change-tracker-C2Z8UbI0.js';
-import { D as Database } from '../database-DvSvONb-.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-DvSvONb-.js';
+import { e as SQLiteConnection, n as SynchronousLevel, a as SQLiteDriver, W as WorkerHostOptions, D as DatabaseOptions, L as LifecycleConfig, M as Migration, m as MigrationResult, R as RollbackResult } from '../types-OGVLZjPS.js';
+export { A as AfterQueryHook, o as AppliedMigration, p as AppliedMigrationEntry, f as BackupScheduleOptions, q as BatchSummary, b as BeforeConnectHook, B as BeforeQueryHook, h as BeforeSubscribeHook, l as CDCMetrics, r as ClusterReadEndpointInfo, C as ClusterStatusInfo, g as ConnectionHookContext, k as ConnectionMetrics, d as DatabaseCloseHook, c as DatabaseOpenHook, s as DriverCapabilities, t as DriverWorkerEntry, H as HookConfig, u as MIGRATION_NAME_RE, i as MetricsConfig, v as MigrationBaseline, w as MigrationSource, N as NodeHealth, x as NodeHealthReason, y as NodeHealthState, O as OpenOptions, Q as QueryHookContext, j as QueryMetrics, z as RunResult, E as SQLiteStatement, S as SirannonOptions, T as Transaction, F as WriterWorkerOptions } from '../types-OGVLZjPS.js';
+import { B as BulkLoadDurability, a as BulkLoadResult } from '../server-options-Bc6WuuFf.js';
+export { c as AuthenticateHook, b as BulkLoadOptions, C as ClientOptions, d as ClusterStatusAuthorizer, e as CorsOptions, R as ReplicationStatusInfo, f as RequestContext, g as ServerExecutionTarget, h as ServerExecutionTargetResolver, S as ServerOptions, W as WSHandlerOptions } from '../server-options-Bc6WuuFf.js';
+export { C as ChangeTracker, a as ChangeTrackerOptions } from '../change-tracker-rTXrPhQq.js';
+import { D as Database } from '../database-DvURlr-n.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-DvURlr-n.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, d as RequestDeniedError, S as SirannonError, T as TransactionError, W as WriteOverloadError } from '../errors-Dei4GdBb.js';
 export { a as LiveQuery, L as LiveQueryOptions, b as LiveQueryState, c as LiveUpdate, R as ResultOp } from '../types-BCejqzNA.js';
 import { B as BaselineFileOption } from '../baseline-D93hcIEE.js';
 import { P as Params, E as ExecuteResult } from '../query-types-BvkzxKQv.js';
 export { C as ChangeEvent, b as ChangeOperation, Q as QueryOptions, R as ReadConcern, a as ReadConcernLevel, c as Subscription, S as SubscriptionBuilder, W as WriteConcern, d as WriteConcernLevel } from '../query-types-BvkzxKQv.js';
-export { S as Sirannon } from '../sirannon-DVYfrNiq.js';
+export { S as Sirannon } from '../sirannon-Bs0WBW1o.js';
 export { D as DatabaseOperations, b as OperationArguments, O as OperationRef, a as OperationRegistry, c as OperationStatement, R as ReadOperation, W as WriteOperation, o as operationName, d as operationRef } from '../operation-registry-6qErmUT2.js';
 import '../types-CjhxcjhA.js';
 
@@ -99,6 +99,8 @@ declare class ConnectionPool {
     static create(options: ConnectionPoolOptions): Promise<ConnectionPool>;
     acquireReader(): SQLiteConnection;
     acquireWriter(): SQLiteConnection;
+    /** Returns the writer and every reader, for an operation that must apply to the whole pool. */
+    connections(): readonly SQLiteConnection[];
     get readerCount(): number;
     get isReadOnly(): boolean;
     close(): Promise<void>;

package/dist/core/index.mjs

@@ -89,6 +89,13 @@ var ConnectionPool = class _ConnectionPool {
     }
     return this.writer;
   }
+  /** Returns the writer and every reader, for an operation that must apply to the whole pool. */
+  connections() {
+    if (this.closed) {
+      throw new ConnectionPoolError("Connection pool is closed");
+    }
+    return this.writer ? [this.writer, ...this.readers] : [...this.readers];
+  }
   get readerCount() {
     return this.readers.length;
   }
@@ -1517,32 +1524,6 @@ var DatabaseWriteController = class {
   }
 };
 
-// src/core/extension-loader.ts
-async function loadExtension(driver, writer, extensionPath) {
-  if (!driver.capabilities.extensions || !driver.resolveExtensionPath) {
-    throw new ExtensionError(extensionPath, "Extensions are not supported by the current driver");
-  }
-  if (!extensionPath || extensionPath.includes("\0")) {
-    throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
-  }
-  for (let i = 0; i < extensionPath.length; i++) {
-    if (extensionPath.charCodeAt(i) <= 31) {
-      throw new ExtensionError(extensionPath, "Extension path contains control characters");
-    }
-  }
-  const segments = extensionPath.split(/[/\\]/);
-  if (segments.includes("..")) {
-    throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
-  }
-  const resolved = driver.resolveExtensionPath(extensionPath);
-  try {
-    const escaped = resolved.replace(/'/g, "''");
-    await writer.exec(`SELECT load_extension('${escaped}')`);
-  } catch (err) {
-    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
-  }
-}
-
 // src/core/hooks/registry.ts
 var HOOK_CONFIG_MAP = {
   onBeforeQuery: "beforeQuery",
@@ -1625,6 +1606,129 @@ var HookRegistry = class {
   }
 };
 
+// src/core/extension-loader.ts
+function assertPathIsSafe(extensionPath) {
+  if (!extensionPath || extensionPath.includes("\0")) {
+    throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
+  }
+  for (let i = 0; i < extensionPath.length; i++) {
+    if (extensionPath.charCodeAt(i) <= 31) {
+      throw new ExtensionError(extensionPath, "Extension path contains control characters");
+    }
+  }
+  const segments = extensionPath.split(/[/\\]/);
+  if (segments.includes("..")) {
+    throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
+  }
+}
+function isAbsolutePath(candidate) {
+  return candidate.startsWith("/") || candidate.startsWith("\\") || /^[A-Za-z]:[/\\]/.test(candidate);
+}
+async function loadExtension(driver, connections, extensionPath) {
+  assertPathIsSafe(extensionPath);
+  if (connections.some((connection) => connection.loadExtension === void 0)) {
+    throw new ExtensionError(
+      extensionPath,
+      driver.capabilities.extensions ? "The current driver declares extension support but opens connections with no loading call" : "Extensions are not supported by the current driver"
+    );
+  }
+  if (driver.capabilities.extensions && !driver.resolveExtensionPath) {
+    throw new ExtensionError(
+      extensionPath,
+      "The current driver declares extension support but resolves no absolute path, which would let the dynamic linker search its own paths"
+    );
+  }
+  const resolved = driver.resolveExtensionPath?.(extensionPath) ?? extensionPath;
+  if (driver.resolveExtensionPath && !isAbsolutePath(resolved)) {
+    throw new ExtensionError(
+      extensionPath,
+      "The current driver resolved the extension to a relative path, which would let the dynamic linker search its own paths"
+    );
+  }
+  for (const connection of connections) {
+    try {
+      await connection.loadExtension?.(resolved);
+    } catch (err) {
+      if (err instanceof SirannonError) throw err;
+      throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+    }
+  }
+  return resolved;
+}
+
+// src/core/loaded-extensions.ts
+function forwardingConnection(connection, onClose) {
+  const { loadExtension: loadExtension2, runBatch, runBatchSummary, runGroup } = connection;
+  const forwarding = {
+    exec: (sql) => connection.exec(sql),
+    prepare: (sql) => connection.prepare(sql),
+    transaction: (fn) => connection.transaction(fn),
+    close: async () => {
+      onClose();
+      await connection.close();
+    }
+  };
+  if (loadExtension2) forwarding.loadExtension = (path) => loadExtension2.call(connection, path);
+  if (runBatch) forwarding.runBatch = (sql, paramsBatch) => runBatch.call(connection, sql, paramsBatch);
+  if (runBatchSummary) {
+    forwarding.runBatchSummary = (sql, paramsBatch) => runBatchSummary.call(connection, sql, paramsBatch);
+  }
+  if (runGroup) forwarding.runGroup = (units) => runGroup.call(connection, units);
+  return forwarding;
+}
+var LoadedExtensions = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  resolvedPaths = [];
+  openedConnections = /* @__PURE__ */ new Set();
+  queue = Promise.resolve();
+  runInTurn(operation) {
+    const result = this.queue.then(operation, operation);
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async loadRecorded(connection) {
+    for (const resolvedPath of this.resolvedPaths) {
+      if (!connection.loadExtension) {
+        throw new ExtensionError(resolvedPath, "The current driver opened a connection with no extension loading call");
+      }
+      await connection.loadExtension(resolvedPath);
+    }
+  }
+  /** Loads an extension onto the pool's connections and every connection opened beyond it, then records it. */
+  load(poolConnections, extensionPath) {
+    return this.runInTurn(async () => {
+      const resolved = await loadExtension(this.driver, [...poolConnections, ...this.openedConnections], extensionPath);
+      if (!this.resolvedPaths.includes(resolved)) this.resolvedPaths.push(resolved);
+    });
+  }
+  /**
+   * Opens a connection, loads every recorded extension onto it, and returns a
+   * connection that forwards to it. Closing the returned connection stops the
+   * tracking and closes the one underneath.
+   *
+   * @param openConnection - Opens the connection this database needs.
+   * @returns The connection to read and write through.
+   */
+  open(openConnection) {
+    return this.runInTurn(async () => {
+      const connection = await openConnection();
+      try {
+        await this.loadRecorded(connection);
+      } catch (err) {
+        await connection.close().catch(() => void 0);
+        throw err;
+      }
+      const tracked = forwardingConnection(connection, () => {
+        this.openedConnections.delete(tracked);
+      });
+      this.openedConnections.add(tracked);
+      return tracked;
+    });
+  }
+};
+
 // src/core/worker/config.ts
 var DEFAULT_MAX_PENDING_WRITES = 1024;
 var DEFAULT_RETRY_AFTER_MS = 1e3;
@@ -1728,12 +1832,14 @@ async function createDatabaseRuntime(id, path, driver, options, internals) {
     driver.createBackupEngine?.()
   );
   const canOpenSnapshotConnection = driver.capabilities.multipleConnections && path !== ":memory:";
+  const extensions = new LoadedExtensions(driver);
+  const openSnapshotConnection = () => extensions.open(() => driver.open(path, { readonly: true, walMode: false }));
   const cdc = new DatabaseCdcController(
     (op) => writerLock.run(op),
     () => pool.acquireWriter(),
     options?.cdcPollInterval ?? 50,
     options?.cdcRetention ?? 36e5,
-    canOpenSnapshotConnection ? () => driver.open(path, { readonly: true, walMode: false }) : null
+    canOpenSnapshotConnection ? openSnapshotConnection : null
   );
   const sync = new DatabaseSyncController(
     (op) => writeGate.run(() => writerLock.run(op)),
@@ -1776,7 +1882,7 @@ async function createDatabaseRuntime(id, path, driver, options, internals) {
     writes,
     reads: { pool, writerLock, observer },
     migrations,
-    loadExtension: (extensionPath) => writerLock.run(() => loadExtension(driver, pool.acquireWriter(), extensionPath))
+    loadExtension: (extensionPath) => writerLock.run(() => extensions.load(pool.connections(), extensionPath))
   };
 }
 async function closeDatabaseRuntime(runtime, closeListeners) {

package/dist/core/writer-worker.mjs

@@ -86,6 +86,17 @@ async function dispatch(req) {
         (outcome) => outcome.ok ? { ok: true, results: outcome.values } : { ok: false, error: serializeError(outcome.error) }
       );
     }
+    case "loadExtension": {
+      const conn = requireConnection();
+      if (!conn.loadExtension) {
+        throw new SirannonError(
+          "The driver rebuilt inside the writer worker opens connections without an extension loading call",
+          "EXTENSION_ERROR"
+        );
+      }
+      await conn.loadExtension(req.path);
+      return void 0;
+    }
     case "close":
       if (connection) await connection.close();
       connection = null;

package/dist/{database-DvSvONb-.d.ts → database-DvURlr-n.d.ts}

@@ -1,7 +1,7 @@
-import { Q as QueryHookContext, g as ConnectionHookContext, h as BeforeSubscribeHook, H as HookConfig, i as MetricsConfig, j as QueryMetrics, k as ConnectionMetrics, l as CDCMetrics, a as SQLiteDriver, D as DatabaseOptions, T as Transaction, e as SQLiteConnection, M as Migration, m as MigrationResult, R as RollbackResult, f as BackupScheduleOptions, B as BeforeQueryHook, A as AfterQueryHook } from './types-CXoPBeDM.js';
+import { Q as QueryHookContext, g as ConnectionHookContext, h as BeforeSubscribeHook, H as HookConfig, i as MetricsConfig, j as QueryMetrics, k as ConnectionMetrics, l as CDCMetrics, a as SQLiteDriver, D as DatabaseOptions, T as Transaction, e as SQLiteConnection, M as Migration, m as MigrationResult, R as RollbackResult, f as BackupScheduleOptions, B as BeforeQueryHook, A as AfterQueryHook } from './types-OGVLZjPS.js';
 import { c as ReplicationChange, C as ConflictResolver, A as ApplyResult, R as ReplicationBatch } from './types-CjhxcjhA.js';
 import { C as ChangeEvent, P as Params, Q as QueryOptions, E as ExecuteResult, S as SubscriptionBuilder } from './query-types-BvkzxKQv.js';
-import { A as AppliedMigrationRow, b as BulkLoadOptions, a as BulkLoadResult } from './server-options-BVAFmguz.js';
+import { A as AppliedMigrationRow, b as BulkLoadOptions, a as BulkLoadResult } from './server-options-Bc6WuuFf.js';
 import { L as LiveQueryOptions, a as LiveQuery } from './types-BCejqzNA.js';
 
 /**

package/dist/driver/better-sqlite3.d.ts

@@ -1,4 +1,4 @@
-import { a as SQLiteDriver } from '../types-CXoPBeDM.js';
+import { a as SQLiteDriver } from '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 
 /**

package/dist/driver/better-sqlite3.mjs

@@ -1,4 +1,4 @@
-import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, WriterWorker, createStatementCache, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-UPKKSUPA.mjs';
+import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, WriterWorker, createStatementCache, loadThroughRuntime, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-BD3XGHFC.mjs';
 import '../chunk-VOYGMAU7.mjs';
 import { defineDriver } from '../chunk-BQFQ65OL.mjs';
 import '../chunk-4ISB7XMA.mjs';
@@ -67,6 +67,9 @@ function createConnection(db) {
         throw err;
       }
     },
+    async loadExtension(extensionPath) {
+      await loadThroughRuntime(extensionPath, () => db.loadExtension(extensionPath));
+    },
     async close() {
       db.close();
     }

package/dist/driver/bun.d.ts

@@ -1,4 +1,4 @@
-import { a as SQLiteDriver } from '../types-CXoPBeDM.js';
+import { a as SQLiteDriver } from '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 
 /**

package/dist/driver/bun.mjs

@@ -1,4 +1,15 @@
-import { defineDriver, synchronousPragmaValue } from '../chunk-DVWQD3GF.mjs';
+import { defineDriver, synchronousPragmaValue, SirannonError, ExtensionError } from '../chunk-GVYLZVUZ.mjs';
+import { resolve } from 'path';
+
+// src/core/driver/extension.ts
+async function loadThroughRuntime(extensionPath, load) {
+  try {
+    load();
+  } catch (err) {
+    if (err instanceof SirannonError) throw err;
+    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+  }
+}
 
 // src/core/driver/values.ts
 var SAFE_INT_BOUND = 9007199254740991n;
@@ -30,6 +41,7 @@ function narrowRowsIntegers(rows) {
 function bunSqlite(driverOptions) {
   return defineDriver({
     capabilities: { multipleConnections: true, extensions: true },
+    resolveExtensionPath: (extensionPath) => resolve(extensionPath),
     async open(path, options) {
       const { Database } = await import('bun:sqlite');
       const db = new Database(path, { readonly: options?.readonly ?? false, safeIntegers: true });
@@ -78,6 +90,9 @@ function bunSqlite(driverOptions) {
             throw err;
           }
         },
+        async loadExtension(extensionPath) {
+          await loadThroughRuntime(extensionPath, () => db.loadExtension(extensionPath));
+        },
         async close() {
           db.close();
         }

package/dist/driver/expo.d.ts

@@ -1,4 +1,4 @@
-import { a as SQLiteDriver } from '../types-CXoPBeDM.js';
+import { a as SQLiteDriver } from '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 
 /**

package/dist/driver/expo.mjs

@@ -1,4 +1,4 @@
-import { defineDriver, synchronousPragmaValue } from '../chunk-DVWQD3GF.mjs';
+import { defineDriver, synchronousPragmaValue, ExtensionError } from '../chunk-GVYLZVUZ.mjs';
 
 // src/drivers/expo/index.ts
 function expoSqlite() {
@@ -42,6 +42,12 @@ function expoSqlite() {
           });
           return result;
         },
+        async loadExtension(extensionPath) {
+          throw new ExtensionError(
+            extensionPath,
+            "expo-sqlite carries no extension loading call, so a device running Expo loads no compiled extension"
+          );
+        },
         async close() {
           await dbHandle.closeAsync();
         }

package/dist/driver/node.d.ts

@@ -1,4 +1,4 @@
-import { a as SQLiteDriver } from '../types-CXoPBeDM.js';
+import { a as SQLiteDriver } from '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 
 /**

package/dist/driver/node.mjs

@@ -1,9 +1,9 @@
-import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, createStatementCache, WriterWorker, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-UPKKSUPA.mjs';
+import { nodeResolveExtensionPath, nodeBackupEngine, nodeWriterContext, createStatementCache, WriterWorker, loadThroughRuntime, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-BD3XGHFC.mjs';
 import '../chunk-VOYGMAU7.mjs';
 import { defineDriver } from '../chunk-BQFQ65OL.mjs';
 import '../chunk-4ISB7XMA.mjs';
 import { synchronousPragmaValue } from '../chunk-OUSWVNWT.mjs';
-import '../chunk-PBRXXISQ.mjs';
+import { ExtensionError } from '../chunk-PBRXXISQ.mjs';
 
 // src/drivers/node/index.ts
 function nodeSqlite(driverOptions) {
@@ -20,7 +20,8 @@ function nodeSqlite(driverOptions) {
     resolveExtensionPath: nodeResolveExtensionPath,
     async open(path, options) {
       const { DatabaseSync } = await import('node:sqlite');
-      const db = new DatabaseSync(path, { readOnly: options?.readonly ?? false });
+      const db = new DatabaseSync(path, { readOnly: options?.readonly ?? false, allowExtension: true });
+      db.enableLoadExtension?.(false);
       if (options?.walMode !== false) db.exec("PRAGMA journal_mode = WAL");
       db.exec(`PRAGMA synchronous = ${synchronousPragmaValue(options?.synchronous)}`);
       db.exec("PRAGMA foreign_keys = ON");
@@ -91,6 +92,22 @@ function nodeSqlite(driverOptions) {
             throw err;
           }
         },
+        async loadExtension(extensionPath) {
+          if (typeof db.loadExtension !== "function" || typeof db.enableLoadExtension !== "function") {
+            throw new ExtensionError(
+              extensionPath,
+              `Node's own SQLite module on ${process.version} carries no extension loading call`
+            );
+          }
+          await loadThroughRuntime(extensionPath, () => {
+            db.enableLoadExtension(true);
+            try {
+              db.loadExtension(extensionPath);
+            } finally {
+              db.enableLoadExtension(false);
+            }
+          });
+        },
         async close() {
           db.close();
         }

package/dist/driver/wa-sqlite.d.ts

@@ -1,4 +1,4 @@
-import { a as SQLiteDriver } from '../types-CXoPBeDM.js';
+import { a as SQLiteDriver } from '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 
 /**

package/dist/driver/wa-sqlite.mjs

@@ -6,6 +6,15 @@ var SirannonError = class extends Error {
     this.name = "SirannonError";
   }
 };
+var ExtensionError = class extends SirannonError {
+  constructor(path, cause) {
+    super(
+      cause ? `Failed to load extension '${path}': ${cause}` : `Failed to load extension '${path}'`,
+      "EXTENSION_ERROR"
+    );
+    this.name = "ExtensionError";
+  }
+};
 
 // src/core/driver/define.ts
 function defineDriver(config) {
@@ -157,6 +166,12 @@ function waSqlite(driverOptions) {
             throw err;
           }
         },
+        async loadExtension(extensionPath) {
+          throw new ExtensionError(
+            extensionPath,
+            "wa-sqlite runs SQLite compiled to WebAssembly, which carries no dynamic loading call, so a browser loads no compiled extension"
+          );
+        },
         async close() {
           sqlite3.close(db);
         }

package/dist/file-migrations/index.d.ts

@@ -1,5 +1,5 @@
 import { B as BaselineFileOption } from '../baseline-D93hcIEE.js';
-import { M as Migration } from '../types-CXoPBeDM.js';
+import { M as Migration } from '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 
 /**

package/dist/{protocol-CEBVo1tO.d.ts → protocol-BQMNEubg.d.ts}

@@ -1,5 +1,5 @@
 import { W as WriteConcern, R as ReadConcern, E as ExecuteResult } from './query-types-BvkzxKQv.js';
-import { B as BulkLoadDurability, a as BulkLoadResult } from './server-options-BVAFmguz.js';
+import { B as BulkLoadDurability, a as BulkLoadResult } from './server-options-Bc6WuuFf.js';
 
 /**
  * Body of `POST /db/{id}/query`.

package/dist/replication/index.d.ts

@@ -1,15 +1,15 @@
 export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-B0np8JS3.js';
 import { H as HLCTimestamp, R as ReplicationBatch, C as ConflictResolver, A as ApplyResult, S as SyncTableManifest } from '../types-CjhxcjhA.js';
 export { a as ConflictContext, b as ConflictResolution, c as ReplicationChange } from '../types-CjhxcjhA.js';
-import { R as ReplicationStatusInfo } from '../server-options-BVAFmguz.js';
-import { r as ClusterReadEndpointInfo, C as ClusterStatusInfo, e as SQLiteConnection, T as Transaction } from '../types-CXoPBeDM.js';
-import { C as CoordinatorRuntimeStatus, g as ReplicationStatus, h as SyncPhase, I as InFlightBatch, P as PeerState, a as ForwardedTransactionResult, b as SyncBatch, c as SyncComplete, d as SyncAck, S as SyncRequest, i as ReplicationConfig, j as SyncState, k as ReplicationErrorEvent, R as ReplicationAck, l as Topology, f as TopologyRole } from '../types-DxoEm08T.js';
-export { F as ForwardedTransaction, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-DxoEm08T.js';
+import { R as ReplicationStatusInfo } from '../server-options-Bc6WuuFf.js';
+import { r as ClusterReadEndpointInfo, C as ClusterStatusInfo, e as SQLiteConnection, T as Transaction } from '../types-OGVLZjPS.js';
+import { C as CoordinatorRuntimeStatus, g as ReplicationStatus, h as SyncPhase, I as InFlightBatch, P as PeerState, a as ForwardedTransactionResult, b as SyncBatch, c as SyncComplete, d as SyncAck, S as SyncRequest, i as ReplicationConfig, j as SyncState, k as ReplicationErrorEvent, R as ReplicationAck, l as Topology, f as TopologyRole } from '../types-BgVF0xhd.js';
+export { F as ForwardedTransaction, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-BgVF0xhd.js';
 import { c as ReplicationGroupState, e as CoordinatorWatchDisposer } from '../types-CMBcFPhb.js';
 export { A as AcquireControllerLeaseInput, a as AcquireControllerLeaseResult, h as AdmitNodeToInSyncSetInput, C as ClusterCoordinator, f as CompareAndAdvancePrimaryTermInput, g as CompareAndAdvancePrimaryTermResult, j as CoordinatorCompatibilityMetadata, k as CoordinatorLease, b as CoordinatorNodeSession, l as CoordinatorPrimary, P as PromoteEligibleReplicaInput, R as RegisterNodeSessionInput, d as ReplicationGroupWatcher, S as SetReplicationGroupStateInput, U as UpdateInSyncSetInput, i as UpdateNodeMaintenanceInput } from '../types-CMBcFPhb.js';
 import { EventEmitter } from 'node:events';
-import { C as ChangeTracker } from '../change-tracker-C2Z8UbI0.js';
-import { D as Database } from '../database-DvSvONb-.js';
+import { C as ChangeTracker } from '../change-tracker-rTXrPhQq.js';
+import { D as Database } from '../database-DvURlr-n.js';
 import { P as Params, Q as QueryOptions, E as ExecuteResult } from '../query-types-BvkzxKQv.js';
 import { S as SirannonError } from '../errors-Dei4GdBb.js';
 import '../operation-registry-6qErmUT2.js';

package/dist/server/index.d.ts

@@ -1,10 +1,10 @@
-import { T as TransactionStatement, Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-CEBVo1tO.js';
-export { b as BatchRequest, c as ErrorResponse, d as ExecuteRequest, e as LoadRequest, f as QueryRequest, g as TransactionRequest, t as toExecuteResponse } from '../protocol-CEBVo1tO.js';
-import { S as Sirannon } from '../sirannon-DVYfrNiq.js';
-import { B as BulkLoadDurability, S as ServerOptions, W as WSHandlerOptions } from '../server-options-BVAFmguz.js';
+import { T as TransactionStatement, Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-BQMNEubg.js';
+export { b as BatchRequest, c as ErrorResponse, d as ExecuteRequest, e as LoadRequest, f as QueryRequest, g as TransactionRequest, t as toExecuteResponse } from '../protocol-BQMNEubg.js';
+import { S as Sirannon } from '../sirannon-Bs0WBW1o.js';
+import { B as BulkLoadDurability, S as ServerOptions, W as WSHandlerOptions } from '../server-options-Bc6WuuFf.js';
 import { W as WriteConcern, R as ReadConcern } from '../query-types-BvkzxKQv.js';
-import '../database-DvSvONb-.js';
-import '../types-CXoPBeDM.js';
+import '../database-DvURlr-n.js';
+import '../types-OGVLZjPS.js';
 import '../types-CjhxcjhA.js';
 import '../types-BCejqzNA.js';
 import '../operation-registry-6qErmUT2.js';

package/dist/{server-options-BVAFmguz.d.ts → server-options-Bc6WuuFf.d.ts}

@@ -1,6 +1,6 @@
 import { a as OperationRegistry } from './operation-registry-6qErmUT2.js';
 import { R as ReplicationBatch, C as ConflictResolver, A as ApplyResult } from './types-CjhxcjhA.js';
-import { N as NodeHealth, T as Transaction, C as ClusterStatusInfo } from './types-CXoPBeDM.js';
+import { N as NodeHealth, T as Transaction, C as ClusterStatusInfo } from './types-OGVLZjPS.js';
 import { P as Params, Q as QueryOptions, E as ExecuteResult } from './query-types-BvkzxKQv.js';
 
 interface AppliedMigrationRow {

package/dist/{sirannon-DVYfrNiq.d.ts → sirannon-Bs0WBW1o.d.ts}

@@ -1,5 +1,5 @@
-import { D as Database } from './database-DvSvONb-.js';
-import { S as SirannonOptions, a as SQLiteDriver, D as DatabaseOptions, M as Migration, B as BeforeQueryHook, A as AfterQueryHook, b as BeforeConnectHook, c as DatabaseOpenHook, d as DatabaseCloseHook } from './types-CXoPBeDM.js';
+import { D as Database } from './database-DvURlr-n.js';
+import { S as SirannonOptions, a as SQLiteDriver, D as DatabaseOptions, M as Migration, B as BeforeQueryHook, A as AfterQueryHook, b as BeforeConnectHook, c as DatabaseOpenHook, d as DatabaseCloseHook } from './types-OGVLZjPS.js';
 
 /**
  * A registry of open SQLite databases, keyed by identifier.

package/dist/transport/grpc.d.ts

@@ -1,10 +1,10 @@
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import { Client, ClientDuplexStream, CallOptions, Metadata, ServiceError, ClientUnaryCall, ChannelCredentials, ClientOptions, ServerDuplexStream, Server } from '@grpc/grpc-js';
 import { HealthImplementation } from 'grpc-health-check';
-import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, N as NodeInfo, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, e as ReplicationTransport, f as TopologyRole, T as TransportConfig } from '../types-DxoEm08T.js';
+import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, N as NodeInfo, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, e as ReplicationTransport, f as TopologyRole, T as TransportConfig } from '../types-BgVF0xhd.js';
 import { R as ReplicationBatch } from '../types-CjhxcjhA.js';
-import '../change-tracker-C2Z8UbI0.js';
-import '../types-CXoPBeDM.js';
+import '../change-tracker-rTXrPhQq.js';
+import '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 import '../types-CMBcFPhb.js';
 

package/dist/transport/memory.d.ts

@@ -1,7 +1,7 @@
-import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-DxoEm08T.js';
+import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-BgVF0xhd.js';
 import { R as ReplicationBatch } from '../types-CjhxcjhA.js';
-import '../change-tracker-C2Z8UbI0.js';
-import '../types-CXoPBeDM.js';
+import '../change-tracker-rTXrPhQq.js';
+import '../types-OGVLZjPS.js';
 import '../query-types-BvkzxKQv.js';
 import '../types-CMBcFPhb.js';
 

package/dist/{types-DxoEm08T.d.ts → types-BgVF0xhd.d.ts}

@@ -1,5 +1,5 @@
-import { C as ChangeTracker } from './change-tracker-C2Z8UbI0.js';
-import { e as SQLiteConnection, N as NodeHealth } from './types-CXoPBeDM.js';
+import { C as ChangeTracker } from './change-tracker-rTXrPhQq.js';
+import { e as SQLiteConnection, N as NodeHealth } from './types-OGVLZjPS.js';
 import { S as SyncTableManifest, R as ReplicationBatch, C as ConflictResolver } from './types-CjhxcjhA.js';
 import { C as ClusterCoordinator, j as CoordinatorCompatibilityMetadata, c as ReplicationGroupState } from './types-CMBcFPhb.js';
 

package/dist/{types-CXoPBeDM.d.ts → types-OGVLZjPS.d.ts}

@@ -496,6 +496,15 @@ interface SQLiteConnection {
     transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
     /** Closes the connection. */
     close(): Promise<void>;
+    /**
+     * Loads a compiled SQLite extension into this connection through the
+     * runtime's own loading call, so a query on this connection can call the
+     * extension's functions. SQLite scopes a loaded extension to the connection
+     * that loaded it, so a caller that needs it everywhere loads it on every
+     * connection. Where the runtime carries no loading call, this rejects with an
+     * error that names that runtime.
+     */
+    loadExtension?(extensionPath: string): Promise<void>;
     /** Optional fast path that applies one statement over many parameter sets. */
     runBatch?(sql: string, paramsBatch: readonly unknown[][]): Promise<RunResult[]>;
     /** Optional fast path that applies one statement over many parameter sets and returns only the totals. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@delali/sirannon-db",
   "type": "module",
-  "version": "0.2.3-next.29",
+  "version": "0.2.3-next.30",
   "description": "A production-grade library that turns SQLite databases into a networked data layer with real-time subscriptions.",
   "author": "Delali (https://sondelali.com)",
   "license": "Apache-2.0",