@korajs/store 1.0.0-beta.2 → 1.0.0-beta.5

package/dist/adapters/sqlite-wasm-shared-host.js

@@ -1,66 +1,61 @@
+import {
+  createSqliteWasmCore
+} from "../chunk-3Y2IERBF.js";
+
 // src/adapters/sqlite-wasm-shared-host.ts
 var SW_REQUEST = "kora-sw-request";
 var SW_RESPONSE = "kora-sw-response";
-var pools = /* @__PURE__ */ new Map();
-function getPool(dbName, workerUrl) {
-  const existing = pools.get(dbName);
-  if (existing) {
-    return existing;
-  }
-  const worker = new Worker(workerUrl, { type: "module" });
-  const entry = { worker, pending: /* @__PURE__ */ new Map() };
-  worker.onmessage = (event) => {
-    const response = event.data;
-    const requestId = entry.pending.get(response.id);
-    if (!requestId) {
-      return;
-    }
-    entry.pending.delete(response.id);
-    const port = findPortForRequest(requestId);
-    if (port) {
-      const msg = {
-        type: SW_RESPONSE,
-        requestId,
-        response
-      };
-      port.postMessage(msg);
+function createSharedWorkerHost(options) {
+  const cores = /* @__PURE__ */ new Map();
+  function coreFor(dbName) {
+    let core = cores.get(dbName);
+    if (!core) {
+      core = options.createCore();
+      cores.set(dbName, core);
     }
-  };
-  pools.set(dbName, entry);
-  return entry;
-}
-var portRequestIds = /* @__PURE__ */ new Map();
-var requestPort = /* @__PURE__ */ new Map();
-function findPortForRequest(requestId) {
-  return requestPort.get(requestId);
-}
-self.onconnect = (event) => {
-  const port = event.ports[0];
-  if (!port) {
-    return;
+    return core;
   }
-  port.start();
-  portRequestIds.set(port, /* @__PURE__ */ new Set());
-  port.addEventListener("message", (messageEvent) => {
-    const data = messageEvent.data;
-    if (data?.type !== SW_REQUEST) {
-      return;
-    }
-    const pool = getPool(data.dbName, data.workerUrl);
-    pool.pending.set(data.request.id, data.requestId);
-    requestPort.set(data.requestId, port);
-    portRequestIds.get(port)?.add(data.requestId);
-    pool.worker.postMessage(data.request);
-  });
-  port.addEventListener("messageerror", () => {
-    const ids = portRequestIds.get(port);
-    if (!ids) {
+  function connect(port) {
+    port.start();
+    port.addEventListener("message", (event) => {
+      const data = event.data;
+      if (data?.type !== SW_REQUEST) {
+        return;
+      }
+      const core = coreFor(data.dbName);
+      void core.handle(data.request).then(
+        (response) => {
+          port.postMessage({ type: SW_RESPONSE, requestId: data.requestId, response });
+        },
+        (error) => {
+          const message = error instanceof Error ? error.message : "SharedWorker core failed";
+          port.postMessage({
+            type: SW_RESPONSE,
+            requestId: data.requestId,
+            response: {
+              id: data.request.id,
+              type: "error",
+              message,
+              code: "SHARED_WORKER_CORE_ERROR"
+            }
+          });
+        }
+      );
+    });
+  }
+  return { connect };
+}
+if (typeof SharedWorkerGlobalScope !== "undefined" && typeof self !== "undefined" && self instanceof SharedWorkerGlobalScope) {
+  const host = createSharedWorkerHost({ createCore: createSqliteWasmCore });
+  self.addEventListener("connect", (event) => {
+    const port = event.ports[0];
+    if (!port) {
       return;
     }
-    for (const requestId of ids) {
-      requestPort.delete(requestId);
-    }
-    portRequestIds.delete(port);
+    host.connect(port);
   });
+}
+export {
+  createSharedWorkerHost
 };
 //# sourceMappingURL=sqlite-wasm-shared-host.js.map

package/dist/adapters/sqlite-wasm-shared-host.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/adapters/sqlite-wasm-shared-host.ts"],"sourcesContent":["/// <reference lib=\"webworker\" />\n/**\n * SharedWorker host: one DedicatedWorker (SQLite WASM) per `dbName` per browser origin.\n *\n * Bundle this file separately and pass its URL as `store.sharedWorkerUrl` alongside `workerUrl`.\n *\n * @example\n * ```typescript\n * createApp({\n *   store: {\n *     workerUrl: '/sqlite-wasm-worker.js',\n *     sharedWorkerUrl: '/sqlite-wasm-shared-host.js',\n *   },\n * })\n * ```\n */\n\nimport type { WorkerRequest, WorkerResponse } from './sqlite-wasm-channel'\n\nconst SW_REQUEST = 'kora-sw-request'\nconst SW_RESPONSE = 'kora-sw-response'\n\ninterface SharedWorkerRpcRequest {\n\ttype: typeof SW_REQUEST\n\trequestId: string\n\tdbName: string\n\tworkerUrl: string\n\trequest: WorkerRequest\n}\n\ninterface SharedWorkerRpcResponse {\n\ttype: typeof SW_RESPONSE\n\trequestId: string\n\tresponse: WorkerResponse\n}\n\ninterface WorkerEntry {\n\tworker: Worker\n\tpending: Map<number, string>\n}\n\ndeclare const self: SharedWorkerGlobalScope\n\nconst pools = new Map<string, WorkerEntry>()\n\nfunction getPool(dbName: string, workerUrl: string): WorkerEntry {\n\tconst existing = pools.get(dbName)\n\tif (existing) {\n\t\treturn existing\n\t}\n\n\tconst worker = new Worker(workerUrl, { type: 'module' })\n\tconst entry: WorkerEntry = { worker, pending: new Map() }\n\n\tworker.onmessage = (event: MessageEvent<WorkerResponse>) => {\n\t\tconst response = event.data\n\t\tconst requestId = entry.pending.get(response.id)\n\t\tif (!requestId) {\n\t\t\treturn\n\t\t}\n\t\tentry.pending.delete(response.id)\n\t\tconst port = findPortForRequest(requestId)\n\t\tif (port) {\n\t\t\tconst msg: SharedWorkerRpcResponse = {\n\t\t\t\ttype: SW_RESPONSE,\n\t\t\t\trequestId,\n\t\t\t\tresponse,\n\t\t\t}\n\t\t\tport.postMessage(msg)\n\t\t}\n\t}\n\n\tpools.set(dbName, entry)\n\treturn entry\n}\n\nconst portRequestIds = new Map<MessagePort, Set<string>>()\nconst requestPort = new Map<string, MessagePort>()\n\nfunction findPortForRequest(requestId: string): MessagePort | undefined {\n\treturn requestPort.get(requestId)\n}\n\nself.onconnect = (event: MessageEvent): void => {\n\tconst port = event.ports[0]\n\tif (!port) {\n\t\treturn\n\t}\n\n\tport.start()\n\tportRequestIds.set(port, new Set())\n\n\tport.addEventListener('message', (messageEvent: MessageEvent<SharedWorkerRpcRequest>) => {\n\t\tconst data = messageEvent.data\n\t\tif (data?.type !== SW_REQUEST) {\n\t\t\treturn\n\t\t}\n\n\t\tconst pool = getPool(data.dbName, data.workerUrl)\n\t\tpool.pending.set(data.request.id, data.requestId)\n\t\trequestPort.set(data.requestId, port)\n\t\tportRequestIds.get(port)?.add(data.requestId)\n\n\t\tpool.worker.postMessage(data.request)\n\t})\n\n\tport.addEventListener('messageerror', () => {\n\t\tconst ids = portRequestIds.get(port)\n\t\tif (!ids) {\n\t\t\treturn\n\t\t}\n\t\tfor (const requestId of ids) {\n\t\t\trequestPort.delete(requestId)\n\t\t}\n\t\tportRequestIds.delete(port)\n\t})\n}\n"],"mappings":";AAmBA,IAAM,aAAa;AACnB,IAAM,cAAc;AAuBpB,IAAM,QAAQ,oBAAI,IAAyB;AAE3C,SAAS,QAAQ,QAAgB,WAAgC;AAChE,QAAM,WAAW,MAAM,IAAI,MAAM;AACjC,MAAI,UAAU;AACb,WAAO;AAAA,EACR;AAEA,QAAM,SAAS,IAAI,OAAO,WAAW,EAAE,MAAM,SAAS,CAAC;AACvD,QAAM,QAAqB,EAAE,QAAQ,SAAS,oBAAI,IAAI,EAAE;AAExD,SAAO,YAAY,CAAC,UAAwC;AAC3D,UAAM,WAAW,MAAM;AACvB,UAAM,YAAY,MAAM,QAAQ,IAAI,SAAS,EAAE;AAC/C,QAAI,CAAC,WAAW;AACf;AAAA,IACD;AACA,UAAM,QAAQ,OAAO,SAAS,EAAE;AAChC,UAAM,OAAO,mBAAmB,SAAS;AACzC,QAAI,MAAM;AACT,YAAM,MAA+B;AAAA,QACpC,MAAM;AAAA,QACN;AAAA,QACA;AAAA,MACD;AACA,WAAK,YAAY,GAAG;AAAA,IACrB;AAAA,EACD;AAEA,QAAM,IAAI,QAAQ,KAAK;AACvB,SAAO;AACR;AAEA,IAAM,iBAAiB,oBAAI,IAA8B;AACzD,IAAM,cAAc,oBAAI,IAAyB;AAEjD,SAAS,mBAAmB,WAA4C;AACvE,SAAO,YAAY,IAAI,SAAS;AACjC;AAEA,KAAK,YAAY,CAAC,UAA8B;AAC/C,QAAM,OAAO,MAAM,MAAM,CAAC;AAC1B,MAAI,CAAC,MAAM;AACV;AAAA,EACD;AAEA,OAAK,MAAM;AACX,iBAAe,IAAI,MAAM,oBAAI,IAAI,CAAC;AAElC,OAAK,iBAAiB,WAAW,CAAC,iBAAuD;AACxF,UAAM,OAAO,aAAa;AAC1B,QAAI,MAAM,SAAS,YAAY;AAC9B;AAAA,IACD;AAEA,UAAM,OAAO,QAAQ,KAAK,QAAQ,KAAK,SAAS;AAChD,SAAK,QAAQ,IAAI,KAAK,QAAQ,IAAI,KAAK,SAAS;AAChD,gBAAY,IAAI,KAAK,WAAW,IAAI;AACpC,mBAAe,IAAI,IAAI,GAAG,IAAI,KAAK,SAAS;AAE5C,SAAK,OAAO,YAAY,KAAK,OAAO;AAAA,EACrC,CAAC;AAED,OAAK,iBAAiB,gBAAgB,MAAM;AAC3C,UAAM,MAAM,eAAe,IAAI,IAAI;AACnC,QAAI,CAAC,KAAK;AACT;AAAA,IACD;AACA,eAAW,aAAa,KAAK;AAC5B,kBAAY,OAAO,SAAS;AAAA,IAC7B;AACA,mBAAe,OAAO,IAAI;AAAA,EAC3B,CAAC;AACF;","names":[]}
+{"version":3,"sources":["../../src/adapters/sqlite-wasm-shared-host.ts"],"sourcesContent":["/// <reference lib=\"webworker\" />\n/**\n * SharedWorker host: runs SQLite WASM directly inside the SharedWorker, one\n * database core per `dbName`, shared by every tab on the origin.\n *\n * A SharedWorker CANNOT spawn a nested `Worker` (the `Worker` constructor is not\n * defined in `SharedWorkerGlobalScope` in Chromium), so the host does not delegate\n * to a dedicated worker. It runs {@link createSqliteWasmCore} in its own scope.\n * Because each request is answered by a Promise from the core, responses are\n * correlated to their caller directly, with no inner-id bookkeeping.\n *\n * Bundle this file separately and pass its URL as `store.sharedWorkerUrl` alongside\n * `workerUrl`. The entry that bundles it must set `__KORA_SQLITE_WASM_URL` (via a\n * `?url` import of the sqlite wasm binary) the same way the dedicated worker entry\n * does, so the core can locate the hashed WASM asset in production builds.\n *\n * @example\n * ```typescript\n * createApp({\n *   store: {\n *     workerUrl: '/sqlite-wasm-worker.js',\n *     sharedWorkerUrl: '/sqlite-wasm-shared-host.js',\n *   },\n * })\n * ```\n */\n\nimport type { WorkerRequest, WorkerResponse } from './sqlite-wasm-channel'\nimport { type SqliteWasmCore, createSqliteWasmCore } from './sqlite-wasm-worker-core'\n\nconst SW_REQUEST = 'kora-sw-request'\nconst SW_RESPONSE = 'kora-sw-response'\n\ninterface SharedWorkerRpcRequest {\n\ttype: typeof SW_REQUEST\n\trequestId: string\n\tdbName: string\n\tworkerUrl: string\n\trequest: WorkerRequest\n}\n\ninterface SharedWorkerRpcResponse {\n\ttype: typeof SW_RESPONSE\n\trequestId: string\n\tresponse: WorkerResponse\n}\n\n/** Minimal structural view of a connected client `MessagePort`. */\nexport interface HostPort {\n\tstart(): void\n\tpostMessage(message: SharedWorkerRpcResponse): void\n\taddEventListener(\n\t\ttype: 'message' | 'messageerror',\n\t\thandler: (event: { data: unknown }) => void,\n\t): void\n}\n\nexport interface SharedWorkerHostOptions {\n\t/** Creates a database core. Injectable so the host routing can be unit-tested. */\n\tcreateCore: () => SqliteWasmCore\n}\n\nexport interface SharedWorkerHost {\n\t/** Wire a newly connected client port into the host. */\n\tconnect(port: HostPort): void\n}\n\n/**\n * Creates the SharedWorker host routing core: one SQLite core per `dbName`, shared\n * by every connected tab, with each request answered directly by the core.\n */\nexport function createSharedWorkerHost(options: SharedWorkerHostOptions): SharedWorkerHost {\n\tconst cores = new Map<string, SqliteWasmCore>()\n\n\tfunction coreFor(dbName: string): SqliteWasmCore {\n\t\tlet core = cores.get(dbName)\n\t\tif (!core) {\n\t\t\tcore = options.createCore()\n\t\t\tcores.set(dbName, core)\n\t\t}\n\t\treturn core\n\t}\n\n\tfunction connect(port: HostPort): void {\n\t\tport.start()\n\n\t\tport.addEventListener('message', (event: { data: unknown }): void => {\n\t\t\tconst data = event.data as SharedWorkerRpcRequest | undefined\n\t\t\tif (data?.type !== SW_REQUEST) {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tconst core = coreFor(data.dbName)\n\t\t\tvoid core.handle(data.request).then(\n\t\t\t\t(response) => {\n\t\t\t\t\tport.postMessage({ type: SW_RESPONSE, requestId: data.requestId, response })\n\t\t\t\t},\n\t\t\t\t(error: unknown) => {\n\t\t\t\t\t// The core catches its own errors, so this only fires on an unexpected\n\t\t\t\t\t// throw. Relay it so the client never hangs waiting for a response.\n\t\t\t\t\tconst message = error instanceof Error ? error.message : 'SharedWorker core failed'\n\t\t\t\t\tport.postMessage({\n\t\t\t\t\t\ttype: SW_RESPONSE,\n\t\t\t\t\t\trequestId: data.requestId,\n\t\t\t\t\t\tresponse: {\n\t\t\t\t\t\t\tid: data.request.id,\n\t\t\t\t\t\t\ttype: 'error',\n\t\t\t\t\t\t\tmessage,\n\t\t\t\t\t\t\tcode: 'SHARED_WORKER_CORE_ERROR',\n\t\t\t\t\t\t},\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t)\n\t\t})\n\t}\n\n\treturn { connect }\n}\n\n// Wire the host to the SharedWorker global only when running as an actual\n// SharedWorker. The guard uses `instanceof SharedWorkerGlobalScope` so it is true\n// in a real SharedWorker and false everywhere else (Node test runtimes, the main\n// thread, a dedicated worker), which keeps `createSharedWorkerHost` unit-testable\n// in isolation. A connection is delivered as a `connect` event whose `ports[0]` is\n// the client MessagePort.\ndeclare const self: SharedWorkerGlobalScope\nif (\n\ttypeof SharedWorkerGlobalScope !== 'undefined' &&\n\ttypeof self !== 'undefined' &&\n\tself instanceof SharedWorkerGlobalScope\n) {\n\tconst host = createSharedWorkerHost({ createCore: createSqliteWasmCore })\n\n\tself.addEventListener('connect', (event: MessageEvent): void => {\n\t\tconst port = event.ports[0]\n\t\tif (!port) {\n\t\t\treturn\n\t\t}\n\t\thost.connect(port as unknown as HostPort)\n\t})\n}\n"],"mappings":";;;;;AA8BA,IAAM,aAAa;AACnB,IAAM,cAAc;AAwCb,SAAS,uBAAuB,SAAoD;AAC1F,QAAM,QAAQ,oBAAI,IAA4B;AAE9C,WAAS,QAAQ,QAAgC;AAChD,QAAI,OAAO,MAAM,IAAI,MAAM;AAC3B,QAAI,CAAC,MAAM;AACV,aAAO,QAAQ,WAAW;AAC1B,YAAM,IAAI,QAAQ,IAAI;AAAA,IACvB;AACA,WAAO;AAAA,EACR;AAEA,WAAS,QAAQ,MAAsB;AACtC,SAAK,MAAM;AAEX,SAAK,iBAAiB,WAAW,CAAC,UAAmC;AACpE,YAAM,OAAO,MAAM;AACnB,UAAI,MAAM,SAAS,YAAY;AAC9B;AAAA,MACD;AAEA,YAAM,OAAO,QAAQ,KAAK,MAAM;AAChC,WAAK,KAAK,OAAO,KAAK,OAAO,EAAE;AAAA,QAC9B,CAAC,aAAa;AACb,eAAK,YAAY,EAAE,MAAM,aAAa,WAAW,KAAK,WAAW,SAAS,CAAC;AAAA,QAC5E;AAAA,QACA,CAAC,UAAmB;AAGnB,gBAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU;AACzD,eAAK,YAAY;AAAA,YAChB,MAAM;AAAA,YACN,WAAW,KAAK;AAAA,YAChB,UAAU;AAAA,cACT,IAAI,KAAK,QAAQ;AAAA,cACjB,MAAM;AAAA,cACN;AAAA,cACA,MAAM;AAAA,YACP;AAAA,UACD,CAAC;AAAA,QACF;AAAA,MACD;AAAA,IACD,CAAC;AAAA,EACF;AAEA,SAAO,EAAE,QAAQ;AAClB;AASA,IACC,OAAO,4BAA4B,eACnC,OAAO,SAAS,eAChB,gBAAgB,yBACf;AACD,QAAM,OAAO,uBAAuB,EAAE,YAAY,qBAAqB,CAAC;AAExE,OAAK,iBAAiB,WAAW,CAAC,UAA8B;AAC/D,UAAM,OAAO,MAAM,MAAM,CAAC;AAC1B,QAAI,CAAC,MAAM;AACV;AAAA,IACD;AACA,SAAK,QAAQ,IAA2B;AAAA,EACzC,CAAC;AACF;","names":[]}

package/dist/adapters/sqlite-wasm-worker.cjs

@@ -22,48 +22,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/adapters/sqlite-wasm-worker.ts
-var db = null;
-var sqlite3Api = null;
-function sendResponse(response) {
-  self.postMessage(response);
-}
-function handleExecute(id, sql, params) {
-  if (!db) {
-    sendResponse({ id, type: "error", message: "Database is not open", code: "DB_NOT_OPEN" });
-    return;
-  }
-  try {
-    db.exec({ sql, bind: params });
-    sendResponse({ id, type: "success" });
-  } catch (error) {
-    sendResponse({ id, type: "error", message: error.message, code: "EXEC_ERROR" });
-  }
-}
-function handleQuery(id, sql, params) {
-  if (!db) {
-    sendResponse({ id, type: "error", message: "Database is not open", code: "DB_NOT_OPEN" });
-    return;
-  }
-  try {
-    const rows = [];
-    db.exec({
-      sql,
-      bind: params,
-      rowMode: "object",
-      callback: (row) => {
-        rows.push({ ...row });
-      }
-    });
-    sendResponse({ id, type: "success", data: rows });
-  } catch (error) {
-    sendResponse({ id, type: "error", message: error.message, code: "QUERY_ERROR" });
-  }
-}
-function opfsDatabaseFilename(dbName) {
-  const base = dbName.replace(/[^a-zA-Z0-9._-]/g, "_");
-  return base.endsWith(".db") ? base : `${base}.db`;
-}
+// src/adapters/sqlite-wasm-worker-core.ts
+var OPFS_POOL_NAME = "kora-opfs";
 var OPFS_INIT_TIMEOUT_MS = 1e4;
 async function withTimeout(promise, timeoutMs, label) {
   let timer;
@@ -81,205 +41,243 @@ async function withTimeout(promise, timeoutMs, label) {
     if (timer !== void 0) clearTimeout(timer);
   }
 }
-async function handleOpen(id, ddlStatements, dbName) {
+function opfsDatabaseFilename(dbName) {
+  const base = dbName.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return base.endsWith(".db") ? base : `${base}.db`;
+}
+function classifyOpfsFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message)) {
+    return "timeout";
+  }
+  if (/lock|already|in use|in-use|NoModificationAllowed|acquire|SyncAccessHandle|being created/i.test(
+    message
+  )) {
+    return "lock-conflict";
+  }
+  return "unsupported";
+}
+var sqlite3Promise = null;
+var opfsPoolPromise = null;
+var opfsFallbackReason;
+async function loadSqlite3() {
+  const sqlite3InitModule = (await import("@sqlite.org/sqlite-wasm")).default;
+  const wasmUrl = globalThis.__KORA_SQLITE_WASM_URL;
+  const initOptions = wasmUrl ? {
+    locateFile: (file) => file.endsWith(".wasm") ? wasmUrl : file
+  } : void 0;
+  const initFn = sqlite3InitModule;
+  return await withTimeout(initFn(initOptions), 6e4, "SQLite3 module init");
+}
+function getSqlite3() {
+  if (!sqlite3Promise) {
+    sqlite3Promise = loadSqlite3();
+  }
+  return sqlite3Promise;
+}
+async function installOpfsPool(sqlite3) {
+  if (!sqlite3.installOpfsSAHPoolVfs) {
+    opfsFallbackReason = "unsupported";
+    return null;
+  }
   try {
-    const sqlite3InitModule = (await import("@sqlite.org/sqlite-wasm")).default;
-    const wasmUrl = globalThis.__KORA_SQLITE_WASM_URL;
-    const initOptions = wasmUrl ? {
-      locateFile: (file) => {
-        if (file.endsWith(".wasm")) return wasmUrl;
-        return file;
-      }
-    } : void 0;
-    const initFn = sqlite3InitModule;
-    const sqlite3 = await withTimeout(
-      initFn(initOptions),
-      6e4,
-      "SQLite3 module init"
+    return await withTimeout(
+      sqlite3.installOpfsSAHPoolVfs({ name: OPFS_POOL_NAME }),
+      OPFS_INIT_TIMEOUT_MS,
+      "OPFS VFS install"
     );
-    sqlite3Api = sqlite3;
-    let useOpfs = false;
-    let fallbackReason;
-    if (sqlite3.installOpfsSAHPoolVfs) {
-      try {
-        const pool = await withTimeout(
-          sqlite3.installOpfsSAHPoolVfs({ name: "kora-opfs" }),
-          OPFS_INIT_TIMEOUT_MS,
-          "OPFS VFS install"
-        );
+  } catch (error) {
+    opfsFallbackReason = classifyOpfsFailure(error);
+    return null;
+  }
+}
+function getOpfsPool(sqlite3) {
+  if (!opfsPoolPromise) {
+    opfsPoolPromise = installOpfsPool(sqlite3);
+  }
+  return opfsPoolPromise;
+}
+function createSqliteWasmCore() {
+  let db = null;
+  let sqlite3Api = null;
+  let persistent = false;
+  async function open(id, ddlStatements, dbName) {
+    try {
+      if (db) {
+        applyDdl(db, ddlStatements);
+        return { id, type: "success", data: buildOpenData() };
+      }
+      const sqlite3 = await getSqlite3();
+      sqlite3Api = sqlite3;
+      const pool = await getOpfsPool(sqlite3);
+      if (pool) {
         db = new pool.OpfsSAHPoolDb(opfsDatabaseFilename(dbName ?? "kora-db"));
-        useOpfs = true;
-      } catch (error) {
-        fallbackReason = classifyOpfsFailure(error);
-        console.warn(
-          `[kora] OPFS unavailable (${fallbackReason}), falling back to in-memory SQLite`
-        );
+        persistent = true;
+      } else {
+        db = new sqlite3.oo1.DB({ filename: ":memory:" });
+        persistent = false;
       }
-    } else {
-      fallbackReason = "unsupported";
-    }
-    if (!useOpfs) {
-      db = new sqlite3.oo1.DB({ filename: ":memory:" });
+      db.exec({ sql: "PRAGMA journal_mode = WAL" });
+      db.exec({ sql: "PRAGMA foreign_keys = ON" });
+      applyDdl(db, ddlStatements);
+      return { id, type: "success", data: buildOpenData() };
+    } catch (error) {
+      return { id, type: "error", message: error.message, code: "INIT_ERROR" };
     }
-    db?.exec({ sql: "PRAGMA journal_mode = WAL" });
-    db?.exec({ sql: "PRAGMA foreign_keys = ON" });
+  }
+  function buildOpenData() {
+    return {
+      persistent,
+      ...persistent ? {} : { fallbackReason: opfsFallbackReason ?? "unsupported" }
+    };
+  }
+  function applyDdl(target, ddlStatements) {
     for (const sql of ddlStatements) {
       if (sql.startsWith("--kora:safe-alter")) {
         try {
-          db?.exec({ sql: sql.replace("--kora:safe-alter\n", "") });
-        } catch (e) {
-          const msg = e.message || "";
+          target.exec({ sql: sql.replace("--kora:safe-alter\n", "") });
+        } catch (error) {
+          const msg = error.message || "";
           if (!msg.includes("duplicate column name")) {
-            throw e;
+            throw error;
           }
         }
       } else {
-        db?.exec({ sql });
+        target.exec({ sql });
       }
     }
-    sendResponse({
-      id,
-      type: "success",
-      data: { persistent: useOpfs, ...fallbackReason ? { fallbackReason } : {} }
-    });
-  } catch (error) {
-    sendResponse({
-      id,
-      type: "error",
-      message: error.message,
-      code: "INIT_ERROR"
-    });
-  }
-}
-function classifyOpfsFailure(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (/timed out|timeout/i.test(message)) {
-    return "timeout";
   }
-  if (/lock|already|in use|in-use|NoModificationAllowed|acquire|SyncAccessHandle|being created/i.test(
-    message
-  )) {
-    return "lock-conflict";
+  function execute(id, sql, params) {
+    if (!db) {
+      return { id, type: "error", message: "Database is not open", code: "DB_NOT_OPEN" };
+    }
+    try {
+      db.exec({ sql, bind: params });
+      return { id, type: "success" };
+    } catch (error) {
+      return { id, type: "error", message: error.message, code: "EXEC_ERROR" };
+    }
   }
-  return "unsupported";
-}
-function handleClose(id) {
-  if (db) {
-    db.close();
-    db = null;
+  function query(id, sql, params) {
+    if (!db) {
+      return { id, type: "error", message: "Database is not open", code: "DB_NOT_OPEN" };
+    }
+    try {
+      const rows = [];
+      db.exec({
+        sql,
+        bind: params,
+        rowMode: "object",
+        callback: (row) => {
+          rows.push({ ...row });
+        }
+      });
+      return { id, type: "success", data: rows };
+    } catch (error) {
+      return { id, type: "error", message: error.message, code: "QUERY_ERROR" };
+    }
   }
-  sendResponse({ id, type: "success" });
-}
-function handleImport(id, data) {
-  if (!db) {
-    sendResponse({ id, type: "error", message: "Database is not open", code: "DB_NOT_OPEN" });
-    return;
+  function close(id) {
+    if (db) {
+      db.close();
+      db = null;
+    }
+    return { id, type: "success" };
   }
-  const dbWithDeserialize = db;
-  if (typeof dbWithDeserialize.deserialize === "function") {
+  function migrate(id, statements) {
+    if (!db) {
+      return { id, type: "error", message: "Database is not open", code: "DB_NOT_OPEN" };
+    }
     try {
-      dbWithDeserialize.deserialize(data);
-      sendResponse({ id, type: "success" });
-      return;
+      for (const sql of statements) {
+        db.exec({ sql });
+      }
+      return { id, type: "success" };
     } catch (error) {
-      sendResponse({ id, type: "error", message: error.message, code: "IMPORT_ERROR" });
-      return;
+      return { id, type: "error", message: error.message, code: "MIGRATE_ERROR" };
     }
   }
-  const sqlite3 = sqlite3Api;
-  if (!sqlite3 || typeof sqlite3.capi?.sqlite3_deserialize === "undefined") {
-    sendResponse({
+  function importData(id, data) {
+    if (!db) {
+      return { id, type: "error", message: "Database is not open", code: "DB_NOT_OPEN" };
+    }
+    const dbWithDeserialize = db;
+    if (typeof dbWithDeserialize.deserialize === "function") {
+      try {
+        dbWithDeserialize.deserialize(data);
+        return { id, type: "success" };
+      } catch (error) {
+        return { id, type: "error", message: error.message, code: "IMPORT_ERROR" };
+      }
+    }
+    if (!sqlite3Api || typeof sqlite3Api.capi?.sqlite3_deserialize === "undefined") {
+      return {
+        id,
+        type: "error",
+        message: "Import not supported in this SQLite WASM runtime",
+        code: "IMPORT_NOT_SUPPORTED"
+      };
+    }
+    return {
       id,
       type: "error",
-      message: "Import not supported in this SQLite WASM runtime",
+      message: "Import requires runtime-specific deserialize wiring and is unavailable in this worker build",
       code: "IMPORT_NOT_SUPPORTED"
-    });
-    return;
+    };
   }
-  sendResponse({
-    id,
-    type: "error",
-    message: "Import requires runtime-specific deserialize wiring and is unavailable in this worker build",
-    code: "IMPORT_NOT_SUPPORTED"
-  });
-}
-function handleMessage(request) {
-  try {
-    switch (request.type) {
-      case "open":
-        handleOpen(request.id, request.ddlStatements, request.dbName);
-        return;
-      case "close":
-        handleClose(request.id);
-        return;
-      case "execute":
-        handleExecute(request.id, request.sql, request.params);
-        return;
-      case "query":
-        handleQuery(request.id, request.sql, request.params);
-        return;
-      case "begin":
-        handleExecute(request.id, "BEGIN");
-        return;
-      case "commit":
-        handleExecute(request.id, "COMMIT");
-        return;
-      case "rollback":
-        handleExecute(request.id, "ROLLBACK");
-        return;
-      case "migrate":
-        if (!db) {
-          sendResponse({
+  async function handle(request) {
+    try {
+      switch (request.type) {
+        case "open":
+          return await open(request.id, request.ddlStatements, request.dbName);
+        case "close":
+          return close(request.id);
+        case "execute":
+          return execute(request.id, request.sql, request.params);
+        case "query":
+          return query(request.id, request.sql, request.params);
+        case "begin":
+          return execute(request.id, "BEGIN");
+        case "commit":
+          return execute(request.id, "COMMIT");
+        case "rollback":
+          return execute(request.id, "ROLLBACK");
+        case "migrate":
+          return migrate(request.id, request.statements);
+        case "import":
+          return importData(request.id, request.data);
+        case "export":
+          return {
             id: request.id,
             type: "error",
-            message: "Database is not open",
-            code: "DB_NOT_OPEN"
-          });
-          return;
-        }
-        try {
-          for (const sql of request.statements) {
-            db.exec({ sql });
-          }
-          sendResponse({ id: request.id, type: "success" });
-        } catch (error) {
-          sendResponse({
+            message: "Export not yet supported in browser worker",
+            code: "EXPORT_NOT_SUPPORTED"
+          };
+        default:
+          return {
             id: request.id,
             type: "error",
-            message: error.message,
-            code: "MIGRATE_ERROR"
-          });
-        }
-        return;
-      case "export":
-        sendResponse({
-          id: request.id,
-          type: "error",
-          message: "Export not yet supported in browser worker",
-          code: "EXPORT_NOT_SUPPORTED"
-        });
-        return;
-      case "import":
-        handleImport(request.id, request.data);
-        return;
-      default:
-        sendResponse({
-          id: request.id,
-          type: "error",
-          message: "Unknown request type",
-          code: "UNKNOWN_REQUEST"
-        });
+            message: "Unknown request type",
+            code: "UNKNOWN_REQUEST"
+          };
+      }
+    } catch (error) {
+      return {
+        id: request.id,
+        type: "error",
+        message: error.message,
+        code: "WORKER_ERROR"
+      };
     }
-  } catch (error) {
-    sendResponse({
-      id: request.id,
-      type: "error",
-      message: error.message,
-      code: "WORKER_ERROR"
-    });
   }
+  return { handle };
 }
+
+// src/adapters/sqlite-wasm-worker.ts
+var core = createSqliteWasmCore();
 self.onmessage = (event) => {
-  handleMessage(event.data);
+  void core.handle(event.data).then((response) => {
+    self.postMessage(response);
+  });
 };
 //# sourceMappingURL=sqlite-wasm-worker.cjs.map