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

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

@@ -1,31 +1,19 @@
+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";
 function createSharedWorkerHost(options) {
-  const pools = /* @__PURE__ */ new Map();
-  function getPool(dbName, workerUrl) {
-    const existing = pools.get(dbName);
-    if (existing) {
-      return existing;
+  const cores = /* @__PURE__ */ new Map();
+  function coreFor(dbName) {
+    let core = cores.get(dbName);
+    if (!core) {
+      core = options.createCore();
+      cores.set(dbName, core);
     }
-    const worker = options.spawnWorker(workerUrl);
-    const entry = { worker, nextInnerId: 1, pending: /* @__PURE__ */ new Map() };
-    worker.onmessage = (event) => {
-      const response = event.data;
-      const waiting = entry.pending.get(response.id);
-      if (!waiting) {
-        return;
-      }
-      entry.pending.delete(response.id);
-      const msg = {
-        type: SW_RESPONSE,
-        requestId: waiting.requestId,
-        response
-      };
-      waiting.port.postMessage(msg);
-    };
-    pools.set(dbName, entry);
-    return entry;
+    return core;
   }
   function connect(port) {
     port.start();
@@ -34,35 +22,38 @@ function createSharedWorkerHost(options) {
       if (data?.type !== SW_REQUEST) {
         return;
       }
-      const entry = getPool(data.dbName, data.workerUrl);
-      const innerId = entry.nextInnerId;
-      entry.nextInnerId += 1;
-      entry.pending.set(innerId, { requestId: data.requestId, port });
-      entry.worker.postMessage({ ...data.request, id: innerId });
-    });
-    port.addEventListener("messageerror", () => {
-      for (const entry of pools.values()) {
-        for (const [innerId, waiting] of entry.pending) {
-          if (waiting.port === port) {
-            entry.pending.delete(innerId);
-          }
+      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 self !== "undefined" && "onconnect" in self) {
-  const host = createSharedWorkerHost({
-    spawnWorker: (workerUrl) => new Worker(workerUrl, { type: "module" })
-  });
-  self.onconnect = (event) => {
+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;
     }
     host.connect(port);
-  };
+  });
 }
 export {
   createSharedWorkerHost

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\n/**\n * Minimal structural view of the inner SQLite DedicatedWorker the host owns.\n * Declared here (rather than using the DOM `Worker` type directly) so the host\n * routing can be unit-tested with a mock worker.\n */\nexport interface HostWorker {\n\tpostMessage(message: WorkerRequest): void\n\tonmessage: ((event: { data: WorkerResponse }) => void) | null\n\tterminate?(): void\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/** Spawns the inner SQLite worker for a database. Injectable for tests. */\n\tspawnWorker: (workerUrl: string) => HostWorker\n}\n\ninterface WorkerEntry {\n\tworker: HostWorker\n\t/**\n\t * Monotonic id assigned to each request FORWARDED to the inner worker. The\n\t * adapter always sends `request.id === 0` (uniqueness is a bridge concern), and\n\t * every tab shares one inner worker, so the host must mint its own unique id per\n\t * request or concurrent requests collide on the correlation key. This mirrors\n\t * `WebWorkerBridge`, which reassigns `id` before posting to its worker.\n\t */\n\tnextInnerId: number\n\t/** innerId -> the client waiting for that response. */\n\tpending: Map<number, { requestId: string; port: HostPort }>\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 inner SQLite worker per\n * `dbName`, fanning requests from every connected tab through it and routing each\n * response back to the exact requester.\n *\n * Correlation is keyed on a host-minted inner id, never on the incoming\n * `request.id` (which is `0` for every request from every tab). This is what keeps\n * concurrent and multi-tab requests from resolving each other's responses.\n */\nexport function createSharedWorkerHost(options: SharedWorkerHostOptions): SharedWorkerHost {\n\tconst pools = new Map<string, WorkerEntry>()\n\n\tfunction getPool(dbName: string, workerUrl: string): WorkerEntry {\n\t\tconst existing = pools.get(dbName)\n\t\tif (existing) {\n\t\t\treturn existing\n\t\t}\n\n\t\tconst worker = options.spawnWorker(workerUrl)\n\t\tconst entry: WorkerEntry = { worker, nextInnerId: 1, pending: new Map() }\n\n\t\tworker.onmessage = (event: { data: WorkerResponse }): void => {\n\t\t\tconst response = event.data\n\t\t\tconst waiting = entry.pending.get(response.id)\n\t\t\tif (!waiting) {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tentry.pending.delete(response.id)\n\t\t\tconst msg: SharedWorkerRpcResponse = {\n\t\t\t\ttype: SW_RESPONSE,\n\t\t\t\trequestId: waiting.requestId,\n\t\t\t\tresponse,\n\t\t\t}\n\t\t\twaiting.port.postMessage(msg)\n\t\t}\n\n\t\tpools.set(dbName, entry)\n\t\treturn entry\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 entry = getPool(data.dbName, data.workerUrl)\n\t\t\tconst innerId = entry.nextInnerId\n\t\t\tentry.nextInnerId += 1\n\t\t\tentry.pending.set(innerId, { requestId: data.requestId, port })\n\t\t\t// Reassign a unique inner id. The client bridge correlates on the outer\n\t\t\t// requestId, so rewriting request.id here is transparent to the caller.\n\t\t\tentry.worker.postMessage({ ...data.request, id: innerId })\n\t\t})\n\n\t\tport.addEventListener('messageerror', (): void => {\n\t\t\t// Best-effort cleanup: drop any in-flight requests routed to this port so a\n\t\t\t// disconnected tab does not leak pending entries.\n\t\t\tfor (const entry of pools.values()) {\n\t\t\t\tfor (const [innerId, waiting] of entry.pending) {\n\t\t\t\t\tif (waiting.port === port) {\n\t\t\t\t\t\tentry.pending.delete(innerId)\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. Guarding this keeps the module importable in Node test runtimes,\n// where `createSharedWorkerHost` is unit-tested directly with mock ports/workers.\ndeclare const self: SharedWorkerGlobalScope\nif (typeof self !== 'undefined' && 'onconnect' in self) {\n\tconst host = createSharedWorkerHost({\n\t\tspawnWorker: (workerUrl: string): HostWorker =>\n\t\t\tnew Worker(workerUrl, { type: 'module' }) as unknown as HostWorker,\n\t})\n\n\tself.onconnect = (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":";AAmBA,IAAM,aAAa;AACnB,IAAM,cAAc;AAsEb,SAAS,uBAAuB,SAAoD;AAC1F,QAAM,QAAQ,oBAAI,IAAyB;AAE3C,WAAS,QAAQ,QAAgB,WAAgC;AAChE,UAAM,WAAW,MAAM,IAAI,MAAM;AACjC,QAAI,UAAU;AACb,aAAO;AAAA,IACR;AAEA,UAAM,SAAS,QAAQ,YAAY,SAAS;AAC5C,UAAM,QAAqB,EAAE,QAAQ,aAAa,GAAG,SAAS,oBAAI,IAAI,EAAE;AAExE,WAAO,YAAY,CAAC,UAA0C;AAC7D,YAAM,WAAW,MAAM;AACvB,YAAM,UAAU,MAAM,QAAQ,IAAI,SAAS,EAAE;AAC7C,UAAI,CAAC,SAAS;AACb;AAAA,MACD;AACA,YAAM,QAAQ,OAAO,SAAS,EAAE;AAChC,YAAM,MAA+B;AAAA,QACpC,MAAM;AAAA,QACN,WAAW,QAAQ;AAAA,QACnB;AAAA,MACD;AACA,cAAQ,KAAK,YAAY,GAAG;AAAA,IAC7B;AAEA,UAAM,IAAI,QAAQ,KAAK;AACvB,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,QAAQ,QAAQ,KAAK,QAAQ,KAAK,SAAS;AACjD,YAAM,UAAU,MAAM;AACtB,YAAM,eAAe;AACrB,YAAM,QAAQ,IAAI,SAAS,EAAE,WAAW,KAAK,WAAW,KAAK,CAAC;AAG9D,YAAM,OAAO,YAAY,EAAE,GAAG,KAAK,SAAS,IAAI,QAAQ,CAAC;AAAA,IAC1D,CAAC;AAED,SAAK,iBAAiB,gBAAgB,MAAY;AAGjD,iBAAW,SAAS,MAAM,OAAO,GAAG;AACnC,mBAAW,CAAC,SAAS,OAAO,KAAK,MAAM,SAAS;AAC/C,cAAI,QAAQ,SAAS,MAAM;AAC1B,kBAAM,QAAQ,OAAO,OAAO;AAAA,UAC7B;AAAA,QACD;AAAA,MACD;AAAA,IACD,CAAC;AAAA,EACF;AAEA,SAAO,EAAE,QAAQ;AAClB;AAMA,IAAI,OAAO,SAAS,eAAe,eAAe,MAAM;AACvD,QAAM,OAAO,uBAAuB;AAAA,IACnC,aAAa,CAAC,cACb,IAAI,OAAO,WAAW,EAAE,MAAM,SAAS,CAAC;AAAA,EAC1C,CAAC;AAED,OAAK,YAAY,CAAC,UAA8B;AAC/C,UAAM,OAAO,MAAM,MAAM,CAAC;AAC1B,QAAI,CAAC,MAAM;AACV;AAAA,IACD;AACA,SAAK,QAAQ,IAA2B;AAAA,EACzC;AACD;","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