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

package/dist/adapters/sqlite-wasm-shared-host.d.cts

@@ -1,2 +1,64 @@
+import { a as WorkerResponse, b as WorkerRequest } from '../sqlite-wasm-channel-CNHRf-m2.cjs';
 
-export {  }
+/**
+ * SharedWorker host: one DedicatedWorker (SQLite WASM) per `dbName` per browser origin.
+ *
+ * Bundle this file separately and pass its URL as `store.sharedWorkerUrl` alongside `workerUrl`.
+ *
+ * @example
+ * ```typescript
+ * createApp({
+ *   store: {
+ *     workerUrl: '/sqlite-wasm-worker.js',
+ *     sharedWorkerUrl: '/sqlite-wasm-shared-host.js',
+ *   },
+ * })
+ * ```
+ */
+
+declare const SW_RESPONSE = "kora-sw-response";
+interface SharedWorkerRpcResponse {
+    type: typeof SW_RESPONSE;
+    requestId: string;
+    response: WorkerResponse;
+}
+/**
+ * Minimal structural view of the inner SQLite DedicatedWorker the host owns.
+ * Declared here (rather than using the DOM `Worker` type directly) so the host
+ * routing can be unit-tested with a mock worker.
+ */
+interface HostWorker {
+    postMessage(message: WorkerRequest): void;
+    onmessage: ((event: {
+        data: WorkerResponse;
+    }) => void) | null;
+    terminate?(): void;
+}
+/** Minimal structural view of a connected client `MessagePort`. */
+interface HostPort {
+    start(): void;
+    postMessage(message: SharedWorkerRpcResponse): void;
+    addEventListener(type: 'message' | 'messageerror', handler: (event: {
+        data: unknown;
+    }) => void): void;
+}
+interface SharedWorkerHostOptions {
+    /** Spawns the inner SQLite worker for a database. Injectable for tests. */
+    spawnWorker: (workerUrl: string) => HostWorker;
+}
+interface SharedWorkerHost {
+    /** Wire a newly connected client port into the host. */
+    connect(port: HostPort): void;
+}
+/**
+ * Creates the SharedWorker host routing core: one inner SQLite worker per
+ * `dbName`, fanning requests from every connected tab through it and routing each
+ * response back to the exact requester.
+ *
+ * Correlation is keyed on a host-minted inner id, never on the incoming
+ * `request.id` (which is `0` for every request from every tab). This is what keeps
+ * concurrent and multi-tab requests from resolving each other's responses.
+ */
+declare function createSharedWorkerHost(options: SharedWorkerHostOptions): SharedWorkerHost;
+
+export { type HostPort, type HostWorker, type SharedWorkerHost, type SharedWorkerHostOptions, createSharedWorkerHost };

package/dist/adapters/sqlite-wasm-shared-host.d.ts

@@ -1,2 +1,64 @@
+import { a as WorkerResponse, b as WorkerRequest } from '../sqlite-wasm-channel-CNHRf-m2.js';
 
-export {  }
+/**
+ * SharedWorker host: one DedicatedWorker (SQLite WASM) per `dbName` per browser origin.
+ *
+ * Bundle this file separately and pass its URL as `store.sharedWorkerUrl` alongside `workerUrl`.
+ *
+ * @example
+ * ```typescript
+ * createApp({
+ *   store: {
+ *     workerUrl: '/sqlite-wasm-worker.js',
+ *     sharedWorkerUrl: '/sqlite-wasm-shared-host.js',
+ *   },
+ * })
+ * ```
+ */
+
+declare const SW_RESPONSE = "kora-sw-response";
+interface SharedWorkerRpcResponse {
+    type: typeof SW_RESPONSE;
+    requestId: string;
+    response: WorkerResponse;
+}
+/**
+ * Minimal structural view of the inner SQLite DedicatedWorker the host owns.
+ * Declared here (rather than using the DOM `Worker` type directly) so the host
+ * routing can be unit-tested with a mock worker.
+ */
+interface HostWorker {
+    postMessage(message: WorkerRequest): void;
+    onmessage: ((event: {
+        data: WorkerResponse;
+    }) => void) | null;
+    terminate?(): void;
+}
+/** Minimal structural view of a connected client `MessagePort`. */
+interface HostPort {
+    start(): void;
+    postMessage(message: SharedWorkerRpcResponse): void;
+    addEventListener(type: 'message' | 'messageerror', handler: (event: {
+        data: unknown;
+    }) => void): void;
+}
+interface SharedWorkerHostOptions {
+    /** Spawns the inner SQLite worker for a database. Injectable for tests. */
+    spawnWorker: (workerUrl: string) => HostWorker;
+}
+interface SharedWorkerHost {
+    /** Wire a newly connected client port into the host. */
+    connect(port: HostPort): void;
+}
+/**
+ * Creates the SharedWorker host routing core: one inner SQLite worker per
+ * `dbName`, fanning requests from every connected tab through it and routing each
+ * response back to the exact requester.
+ *
+ * Correlation is keyed on a host-minted inner id, never on the incoming
+ * `request.id` (which is `0` for every request from every tab). This is what keeps
+ * concurrent and multi-tab requests from resolving each other's responses.
+ */
+declare function createSharedWorkerHost(options: SharedWorkerHostOptions): SharedWorkerHost;
+
+export { type HostPort, type HostWorker, type SharedWorkerHost, type SharedWorkerHostOptions, createSharedWorkerHost };

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

@@ -1,66 +1,70 @@
 // 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;
+function createSharedWorkerHost(options) {
+  const pools = /* @__PURE__ */ new Map();
+  function getPool(dbName, workerUrl) {
+    const existing = pools.get(dbName);
+    if (existing) {
+      return existing;
     }
-    entry.pending.delete(response.id);
-    const port = findPortForRequest(requestId);
-    if (port) {
+    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,
+        requestId: waiting.requestId,
         response
       };
-      port.postMessage(msg);
-    }
-  };
-  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;
+      waiting.port.postMessage(msg);
+    };
+    pools.set(dbName, entry);
+    return entry;
   }
-  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);
+  function connect(port) {
+    port.start();
+    port.addEventListener("message", (event) => {
+      const data = event.data;
+      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);
+          }
+        }
+      }
+    });
+  }
+  return { connect };
+}
+if (typeof self !== "undefined" && "onconnect" in self) {
+  const host = createSharedWorkerHost({
+    spawnWorker: (workerUrl) => new Worker(workerUrl, { type: "module" })
   });
-  port.addEventListener("messageerror", () => {
-    const ids = portRequestIds.get(port);
-    if (!ids) {
+  self.onconnect = (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: 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":[]}

package/dist/adapters/sqlite-wasm.cjs

@@ -21,7 +21,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/errors.ts
-var import_core, AdapterError, StoreNotOpenError, WorkerTimeoutError;
+var import_core, AdapterError, StoreNotOpenError, WorkerTimeoutError, NoLeaderError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
@@ -48,6 +48,16 @@ var init_errors = __esm({
         this.name = "WorkerTimeoutError";
       }
     };
+    NoLeaderError = class extends import_core.KoraError {
+      constructor(operation) {
+        super(
+          `No live leader tab is answering multi-tab storage RPC for operation "${operation}"`,
+          "NO_LEADER",
+          { operation }
+        );
+        this.name = "NoLeaderError";
+      }
+    };
   }
 });
 
@@ -270,45 +280,73 @@ var SharedWorkerClientBridge = class {
 init_errors();
 var RPC_REQUEST = "kora-worker-request";
 var RPC_RESPONSE = "kora-worker-response";
+var LEADER_PING = "kora-leader-ping";
+var LEADER_PONG = "kora-leader-pong";
+var DEFAULT_LIVENESS_PROBE_MS = 2e3;
 function isSharedWorkerStorageSupported() {
   return typeof globalThis !== "undefined" && typeof SharedWorker !== "undefined";
 }
 function isMultiTabStorageSupported() {
   return typeof globalThis !== "undefined" && typeof BroadcastChannel !== "undefined" && typeof navigator !== "undefined" && typeof navigator.locks?.request === "function";
 }
-async function acquireTabStorageSession(dbName) {
+async function acquireTabStorageSession(dbName, options) {
   const channelName = `kora-storage-${dbName}`;
+  const lockName = `kora-leader-${dbName}`;
   if (!isMultiTabStorageSupported()) {
     return { role: "leader", channelName };
   }
   return new Promise((resolve) => {
     let releaseHeld;
-    void navigator.locks.request(
-      `kora-leader-${dbName}`,
-      { mode: "exclusive", ifAvailable: true },
-      (lock) => {
-        if (lock === null) {
-          resolve({ role: "follower", channelName });
-          return;
-        }
-        resolve({
-          role: "leader",
-          channelName,
-          releaseLock: async () => {
-            releaseHeld?.();
-          }
-        });
-        return new Promise((release) => {
-          releaseHeld = release;
-        });
+    void navigator.locks.request(lockName, { mode: "exclusive", ifAvailable: true }, (lock) => {
+      if (lock === null) {
+        resolve(startFollowerSession(channelName, lockName, options));
+        return;
       }
-    );
+      resolve({
+        role: "leader",
+        channelName,
+        releaseLock: async () => {
+          releaseHeld?.();
+        }
+      });
+      return new Promise((release) => {
+        releaseHeld = release;
+      });
+    });
   });
 }
+function startFollowerSession(channelName, lockName, options) {
+  let promoted = false;
+  let releasePromotedLock;
+  const abort = new AbortController();
+  void navigator.locks.request(lockName, { mode: "exclusive", signal: abort.signal }, () => {
+    promoted = true;
+    options?.onPromote?.();
+    return new Promise((release) => {
+      releasePromotedLock = release;
+    });
+  }).catch(() => {
+  });
+  return {
+    role: "follower",
+    channelName,
+    cancelPromotionWatch: () => {
+      if (promoted) {
+        releasePromotedLock?.();
+      } else {
+        abort.abort();
+      }
+    }
+  };
+}
 function startLeaderRpcRelay(channelName, bridge) {
   const channel = new BroadcastChannel(channelName);
   const onMessage = (event) => {
     const data = event.data;
+    if (data?.type === LEADER_PING) {
+      channel.postMessage({ type: LEADER_PONG });
+      return;
+    }
     if (data?.type !== RPC_REQUEST) {
       return;
     }
@@ -344,9 +382,11 @@ var FollowerBroadcastBridge = class {
   channel;
   pending = /* @__PURE__ */ new Map();
   timeoutMs;
+  livenessProbeMs;
   terminated = false;
-  constructor(channelName, timeoutMs = 3e4) {
+  constructor(channelName, timeoutMs = 3e4, livenessProbeMs = DEFAULT_LIVENESS_PROBE_MS) {
     this.timeoutMs = timeoutMs;
+    this.livenessProbeMs = Math.min(livenessProbeMs, timeoutMs);
     this.channel = new BroadcastChannel(channelName);
     this.channel.addEventListener("message", (event) => {
       const data = event.data;
@@ -360,6 +400,48 @@ var FollowerBroadcastBridge = class {
       }
     });
   }
+  /**
+   * Readiness handshake: resolves `true` as soon as a live leader answers a ping,
+   * or `false` if none answers within the budget. The adapter calls this before
+   * its first RPC so a follower created before a leader relay is live retries the
+   * handshake instead of firing into the void and waiting out the full timeout.
+   */
+  async waitForLeader(timeoutMs = 3e3, attempts = 3) {
+    const perAttempt = Math.max(50, Math.floor(timeoutMs / Math.max(1, attempts)));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      if (this.terminated) {
+        return false;
+      }
+      if (await this.pingLeader(perAttempt)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Sends one liveness ping and resolves whether a leader answered in time. */
+  pingLeader(timeoutMs) {
+    if (this.terminated) {
+      return Promise.resolve(false);
+    }
+    return new Promise((resolve) => {
+      const onPong = (event) => {
+        if (event.data?.type === LEADER_PONG) {
+          cleanup();
+          resolve(true);
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.channel.removeEventListener("message", onPong);
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        resolve(false);
+      }, timeoutMs);
+      this.channel.addEventListener("message", onPong);
+      this.channel.postMessage({ type: LEADER_PING });
+    });
+  }
   async send(request) {
     if (this.terminated) {
       return {
@@ -372,19 +454,25 @@ var FollowerBroadcastBridge = class {
     const requestId = crypto.randomUUID();
     const msg = { type: RPC_REQUEST, requestId, request };
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
+      const settle = (fn) => {
+        clearTimeout(timer);
+        clearTimeout(probe);
         this.pending.delete(requestId);
-        reject(new WorkerTimeoutError(`follower-rpc:${request.type}`, this.timeoutMs));
+        fn();
+      };
+      const timer = setTimeout(() => {
+        settle(() => reject(new WorkerTimeoutError(`follower-rpc:${request.type}`, this.timeoutMs)));
       }, this.timeoutMs);
+      const probe = setTimeout(() => {
+        void this.pingLeader(this.livenessProbeMs).then((alive) => {
+          if (!alive && this.pending.has(requestId)) {
+            settle(() => reject(new NoLeaderError(`follower-rpc:${request.type}`)));
+          }
+        });
+      }, this.livenessProbeMs);
       this.pending.set(requestId, {
-        resolve: (response) => {
-          clearTimeout(timer);
-          resolve(response);
-        },
-        reject: (error) => {
-          clearTimeout(timer);
-          reject(error);
-        }
+        resolve: (response) => settle(() => resolve(response)),
+        reject: (error) => settle(() => reject(error))
       });
       this.channel.postMessage(msg);
     });
@@ -416,6 +504,9 @@ var SqliteWasmAdapter = class {
   emitter;
   tabSession = null;
   sharedWorker = null;
+  /** Retained so a follower promoted to leader can re-open its own worker. */
+  schema = null;
+  promoting = false;
   constructor(options = {}) {
     this.injectedBridge = options.bridge;
     this.workerUrl = options.workerUrl;
@@ -434,22 +525,29 @@ var SqliteWasmAdapter = class {
       this.sharedWorker = new SharedWorker(sharedUrl, { name: `kora-sw-${this.dbName}` });
       this.bridge = new SharedWorkerClientBridge(this.sharedWorker, this.dbName, workerUrlString);
     } else if (this.workerUrl) {
-      this.tabSession = await acquireTabStorageSession(this.dbName);
+      this.schema = schema;
+      this.tabSession = await acquireTabStorageSession(this.dbName, {
+        onPromote: () => {
+          void this.promoteToLeader();
+        }
+      });
       const { WebWorkerBridge: WebWorkerBridge2 } = await Promise.resolve().then(() => (init_sqlite_wasm_channel(), sqlite_wasm_channel_exports));
       if (this.tabSession.role === "leader") {
         const workerBridge = new WebWorkerBridge2(this.workerUrl, this.workerResponseTimeoutMs);
         this.tabSession.stopRelay = startLeaderRpcRelay(this.tabSession.channelName, workerBridge);
         this.bridge = workerBridge;
       } else {
-        this.bridge = new FollowerBroadcastBridge(
+        const followerBridge = new FollowerBroadcastBridge(
           this.tabSession.channelName,
           this.workerResponseTimeoutMs
         );
+        this.bridge = followerBridge;
         this.emitter?.emit({
           type: "store:db-name-collision",
           dbName: this.dbName,
           message: `Another runtime on this origin is already using database "${this.dbName}"; this runtime is sharing it as a follower. If these are separate apps, give each a distinct store name.`
         });
+        await followerBridge.waitForLeader();
       }
     } else {
       throw new AdapterError(
@@ -499,6 +597,7 @@ var SqliteWasmAdapter = class {
       await this.sendRequest({ id: 0, type: "close" });
     } finally {
       this.tabSession?.stopRelay?.();
+      this.tabSession?.cancelPromotionWatch?.();
       if (this.tabSession?.releaseLock) {
         await this.tabSession.releaseLock();
       }
@@ -509,6 +608,30 @@ var SqliteWasmAdapter = class {
       this.opened = false;
     }
   }
+  /**
+   * Promotes a follower to leader after the previous leader released the storage
+   * lock (its tab closed or crashed). The lock is only granted once the old leader
+   * is gone, so opening our own worker here is safe from the OPFS single-writer
+   * rule. In-flight follower RPCs are rejected and left to the caller / reactive
+   * layer to retry against the new leader.
+   */
+  async promoteToLeader() {
+    if (this.promoting || !this.opened || this.workerUrl === void 0 || this.schema === null) {
+      return;
+    }
+    this.promoting = true;
+    const { WebWorkerBridge: WebWorkerBridge2 } = await Promise.resolve().then(() => (init_sqlite_wasm_channel(), sqlite_wasm_channel_exports));
+    const workerBridge = new WebWorkerBridge2(this.workerUrl, this.workerResponseTimeoutMs);
+    const previousBridge = this.bridge;
+    this.bridge = workerBridge;
+    if (this.tabSession) {
+      this.tabSession.role = "leader";
+      this.tabSession.stopRelay = startLeaderRpcRelay(this.tabSession.channelName, workerBridge);
+    }
+    previousBridge?.terminate();
+    const ddlStatements = (0, import_core2.generateFullDDL)(this.schema);
+    await this.sendRequest({ id: 0, type: "open", ddlStatements, dbName: this.dbName });
+  }
   async execute(sql, params) {
     this.guardOpen();
     const response = await this.sendRequest({ id: 0, type: "execute", sql, params });