@evolu/web 2.4.0 → 3.0.0-next.1

package/README.md

@@ -1,5 +1,7 @@
 # Evolu for Web
 
+This package provides Evolu for the web platform (browsers). We use "web" rather than "browser" because "web platform" is the standard W3C terminology for browser APIs and aligns with ecosystem conventions.
+
 ## Documentation
 
 For detailed information and usage examples, please visit [evolu.dev](https://www.evolu.dev).
@@ -10,4 +12,4 @@ The Evolu community is on [GitHub Discussions](https://github.com/evoluhq/evolu/
 
 To chat with other community members, you can join the [Evolu Discord](https://discord.gg/2J8yyyyxtZ).
 
-[![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/evoluhq.svg?style=social&label=Follow%20%40evoluhq)](https://twitter.com/evoluhq)
+[![X](https://img.shields.io/twitter/url/https/x.com/evoluhq.svg?style=social&label=Follow%20%40evoluhq)](https://x.com/evoluhq)

package/dist/src/Platform.d.ts

@@ -0,0 +1,3 @@
+import type { ReloadApp } from "@evolu/common";
+export declare const reloadApp: ReloadApp;
+//# sourceMappingURL=Platform.d.ts.map

package/dist/src/Platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Platform.d.ts","sourceRoot":"","sources":["../../src/Platform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,eAAO,MAAM,SAAS,EAAE,SAMvB,CAAC"}

package/dist/src/{local-first/Platform.js → Platform.js}

@@ -2,5 +2,5 @@ export const reloadApp = (url) => {
     if (typeof document === "undefined") {
         return;
     }
-    location.replace(url);
+    location.replace(url ?? "/");
 };

package/dist/src/Sqlite.d.ts

@@ -0,0 +1,3 @@
+import type { CreateSqliteDriver } from "@evolu/common";
+export declare const createWasmSqliteDriver: CreateSqliteDriver;
+//# sourceMappingURL=Sqlite.d.ts.map

package/dist/src/Sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sqlite.d.ts","sourceRoot":"","sources":["../../src/Sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAa,MAAM,eAAe,CAAC;AA4BnE,eAAO,MAAM,sBAAsB,EAAE,kBA6GlC,CAAC"}

package/dist/src/Sqlite.js

@@ -0,0 +1,162 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { bytesToHex, createPreparedStatementsCache, ok } from "@evolu/common";
+import sqlite3InitModule, {} from "@evolu/sqlite-wasm";
+// @ts-expect-error Missing types.
+globalThis.sqlite3ApiConfig = {
+    warn: (arg) => {
+        // Ignore irrelevant warning.
+        // https://github.com/sqlite/sqlite-wasm/issues/62
+        if (typeof arg === "string" &&
+            arg.startsWith("Ignoring inability to install OPFS sqlite3_vfs"))
+            return;
+        // eslint-disable-next-line no-console
+        console.warn(arg);
+    },
+};
+// Init ASAP.
+const sqlite3Promise = sqlite3InitModule();
+const fileName = "evolu1.db";
+export const createWasmSqliteDriver = (name, options) => async () => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const sqlite3 = await sqlite3Promise;
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        const useDatabase = (database) => disposer.adopt(database, (database) => {
+            database.close();
+        });
+        let deleteDatabaseFile = false;
+        const createOpfsSAHPoolVfs = async (options) => {
+            const pool = await sqlite3.installOpfsSAHPoolVfs(options);
+            if (pool.isPaused())
+                await pool.unpauseVfs();
+            disposer.defer(() => {
+                if (deleteDatabaseFile)
+                    pool.unlink(`/${fileName}`);
+                pool.pauseVfs();
+            });
+            return pool;
+        };
+        let db;
+        switch (options?.mode) {
+            case "memory":
+                db = useDatabase(new sqlite3.oo1.DB(":memory:"));
+                break;
+            case "encrypted": {
+                // MultipleCiphers encryption requires its VFS wrapper for OPFS SAH-pool.
+                // @ts-expect-error Missing types (update @evolu/sqlite-wasm types)
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                sqlite3.capi.sqlite3mc_vfs_create("opfs", 1);
+                const pool = await createOpfsSAHPoolVfs({
+                    directory: `.${name}`,
+                });
+                db = useDatabase(new pool.OpfsSAHPoolDb(
+                // SQLite normalizes this URI filename to SAH-pool path "/evolu1.db".
+                `file:${fileName}?vfs=multipleciphers-opfs-sahpool`));
+                db.exec(`
+          PRAGMA cipher = 'sqlcipher';
+          PRAGMA key = "x'${bytesToHex(options.encryptionKey)}'";
+        `);
+                break;
+            }
+            default: {
+                const pool = await createOpfsSAHPoolVfs({ name });
+                db = useDatabase(new pool.OpfsSAHPoolDb(`file:${fileName}`));
+            }
+        }
+        const cache = disposer.use(createPreparedStatementsCache((sql) => db.prepare(sql), (statement) => {
+            statement.finalize();
+        }));
+        const disposables = disposer.move();
+        return ok({
+            exec: (query) => {
+                const prepared = cache.get(query);
+                if (prepared) {
+                    if (query.parameters.length > 0)
+                        prepared.bind(query.parameters);
+                    const rows = [];
+                    while (prepared.step()) {
+                        rows.push(prepared.get({}));
+                    }
+                    prepared.reset();
+                    return {
+                        rows: rows,
+                        changes: db.changes(),
+                    };
+                }
+                const rows = db.exec(query.sql, {
+                    returnValue: "resultRows",
+                    rowMode: "object",
+                    bind: query.parameters,
+                });
+                const changes = db.changes();
+                return { rows, changes };
+            },
+            export: () => sqlite3.capi.sqlite3_js_db_export(db),
+            deleteDatabase: () => {
+                deleteDatabaseFile = true;
+                disposables.dispose();
+            },
+            [Symbol.dispose]: () => {
+                disposables.dispose();
+            },
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+};

package/dist/src/Task.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Web platform-specific Task utilities.
+ *
+ * @module
+ */
+import { type CreateRun, type RunDefaultDeps } from "@evolu/common";
+/**
+ * Creates {@link Run} for the browser with global error handling.
+ *
+ * Registers `error` and `unhandledrejection` handlers that log errors to the
+ * console. Handlers are removed when the Run is disposed.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const console = createConsole({
+ *   formatter: createConsoleFormatter()({
+ *     timestampFormat: "relative",
+ *   }),
+ * });
+ *
+ * await using run = createRun({ console });
+ * await using disposer = new AsyncDisposableStack();
+ *
+ * disposer.use(await run.orThrow(startApp()));
+ * ```
+ */
+export declare const createRun: CreateRun<RunDefaultDeps>;
+//# sourceMappingURL=Task.d.ts.map

package/dist/src/Task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Task.d.ts","sourceRoot":"","sources":["../../src/Task.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,cAAc,CAuB/C,CAAC"}

package/dist/src/Task.js

@@ -0,0 +1,38 @@
+/**
+ * Web platform-specific Task utilities.
+ *
+ * @module
+ */
+import { createRun as createCommonRun, createUnknownError, } from "@evolu/common";
+/**
+ * Creates {@link Run} for the browser with global error handling.
+ *
+ * Registers `error` and `unhandledrejection` handlers that log errors to the
+ * console. Handlers are removed when the Run is disposed.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const console = createConsole({
+ *   formatter: createConsoleFormatter()({
+ *     timestampFormat: "relative",
+ *   }),
+ * });
+ *
+ * await using run = createRun({ console });
+ * await using disposer = new AsyncDisposableStack();
+ *
+ * disposer.use(await run.orThrow(startApp()));
+ * ```
+ */
+export const createRun = (deps) => {
+    const run = createCommonRun(deps);
+    const console = run.deps.console.child("global");
+    globalThis.addEventListener("error", (event) => {
+        console.error("error", createUnknownError(event.error));
+    }, { signal: run.signal });
+    globalThis.addEventListener("unhandledrejection", (event) => {
+        console.error("unhandledrejection", createUnknownError(event.reason));
+    }, { signal: run.signal });
+    return run;
+};

package/dist/src/Worker.d.ts

@@ -0,0 +1,60 @@
+import type { CreateBroadcastChannel, CreateBroadcastChannelDep, CreateMessageChannelDep, CreateMessagePort, MessageChannel, SharedWorker, SharedWorkerSelf, Worker, WorkerDeps, WorkerSelf } from "@evolu/common";
+/** Creates a {@link Worker} from a Web Worker. */
+export declare const createWorker: <Input, Output>(nativeWorker: globalThis.Worker) => Worker<Input, Output>;
+/**
+ * Installs a one-tab SharedWorker polyfill backed by a Web Worker.
+ *
+ * Use it before constructing a SharedWorker in browsers without native
+ * SharedWorker support.
+ */
+export declare const installOneTabSharedWorkerPolyfill: () => void;
+/**
+ * Creates a {@link SharedWorker} from a Web SharedWorker.
+ *
+ * Call {@link installOneTabSharedWorkerPolyfill} first to support browsers
+ * without native SharedWorker support.
+ */
+export declare const createSharedWorker: <Input, Output = never>(nativeSharedWorker: globalThis.SharedWorker) => SharedWorker<Input, Output>;
+/**
+ * Creates a {@link MessageChannel} from a Web MessageChannel.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const channel = createMessageChannel<Request, Response>();
+ * channel.port1.onMessage = (response) => console.log(response);
+ * channel.port1.postMessage({ type: "ping" });
+ * ```
+ */
+export declare const createMessageChannel: <Input, Output = never>() => MessageChannel<Input, Output>;
+/**
+ * Creates an Evolu {@link MessagePort} from a Web MessagePort.
+ *
+ * Use this for ports received via postMessage transfer.
+ */
+export declare const createMessagePort: CreateMessagePort;
+/** Creates an Evolu {@link BroadcastChannel} from a Web BroadcastChannel. */
+export declare const createBroadcastChannel: CreateBroadcastChannel;
+/**
+ * Creates an Evolu {@link WorkerSelf} from a Web `DedicatedWorkerGlobalScope`
+ * (`self` inside a dedicated worker).
+ */
+export declare const createWorkerSelf: <Input, Output = never>(nativeSelf: globalThis.DedicatedWorkerGlobalScope) => WorkerSelf<Input, Output>;
+/**
+ * Creates an Evolu {@link SharedWorkerSelf} from a Web `SharedWorkerGlobalScope`
+ * (`self` inside a shared worker).
+ *
+ * Disposing closes the shared worker scope for all connected clients.
+ */
+export declare const createSharedWorkerSelf: <Input, Output = never>(nativeSelf: globalThis.SharedWorkerGlobalScope) => SharedWorkerSelf<Input, Output>;
+/**
+ * Creates a one-tab {@link SharedWorkerSelf} polyfill for browsers without
+ * native SharedWorker support.
+ *
+ * Delivers one synthetic `onConnect` port, queues startup messages until
+ * `onMessage` is set, and does not share state across tabs.
+ */
+export declare const createOneTabSharedWorkerSelfPolyfill: <Input, Output = never>(nativeSelf: globalThis.DedicatedWorkerGlobalScope) => SharedWorkerSelf<Input, Output>;
+/** Creates deps shared by web worker entry points. */
+export declare const createWorkerDeps: () => WorkerDeps & CreateBroadcastChannelDep & CreateMessageChannelDep;
+//# sourceMappingURL=Worker.d.ts.map

package/dist/src/Worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/Worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,EACvB,iBAAiB,EACjB,cAAc,EAGd,YAAY,EACZ,gBAAgB,EAEhB,MAAM,EACN,UAAU,EACV,UAAU,EACX,MAAM,eAAe,CAAC;AAQvB,kDAAkD;AAClD,eAAO,MAAM,YAAY,GAAI,KAAK,EAAE,MAAM,EACxC,cAAc,UAAU,CAAC,MAAM,KAC9B,MAAM,CAAC,KAAK,EAAE,MAAM,CAAuB,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,QAAO,IAiBpD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,EACtD,oBAAoB,UAAU,CAAC,YAAY,KAC1C,YAAY,CAAC,KAAK,EAAE,MAAM,CAM5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,OAAK,cAAc,CAC3E,KAAK,EACL,MAAM,CAcP,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBACuB,CAAC;AAExD,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,EAAE,sBAoCpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,EACpD,YAAY,UAAU,CAAC,0BAA0B,KAChD,UAAU,CAAC,KAAK,EAAE,MAAM,CAAoC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,EAC1D,YAAY,UAAU,CAAC,uBAAuB,KAC7C,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAkBhC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,EACxE,YAAY,UAAU,CAAC,0BAA0B,KAChD,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAyEhC,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,gBAAgB,QAAO,UAAU,GAC5C,yBAAyB,GACzB,uBAWD,CAAC"}

package/dist/src/Worker.js

@@ -0,0 +1,328 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { assert, assertNotDisposed, createConsole, createConsoleStoreOutput, } from "@evolu/common";
+/** Creates a {@link Worker} from a Web Worker. */
+export const createWorker = (nativeWorker) => wrap(nativeWorker);
+/**
+ * Installs a one-tab SharedWorker polyfill backed by a Web Worker.
+ *
+ * Use it before constructing a SharedWorker in browsers without native
+ * SharedWorker support.
+ */
+export const installOneTabSharedWorkerPolyfill = () => {
+    if (typeof globalThis.SharedWorker === "function")
+        return;
+    Object.defineProperty(globalThis, "SharedWorker", {
+        configurable: true,
+        writable: true,
+        value: class {
+            port;
+            constructor(scriptURL, options) {
+                this.port = new globalThis.Worker(scriptURL, options);
+            }
+        },
+    });
+};
+/**
+ * Creates a {@link SharedWorker} from a Web SharedWorker.
+ *
+ * Call {@link installOneTabSharedWorkerPolyfill} first to support browsers
+ * without native SharedWorker support.
+ */
+export const createSharedWorker = (nativeSharedWorker) => {
+    const port = wrap(nativeSharedWorker.port);
+    return {
+        port,
+        [Symbol.dispose]: port[Symbol.dispose],
+    };
+};
+/**
+ * Creates a {@link MessageChannel} from a Web MessageChannel.
+ *
+ * ### Example
+ *
+ * ```ts
+ * const channel = createMessageChannel<Request, Response>();
+ * channel.port1.onMessage = (response) => console.log(response);
+ * channel.port1.postMessage({ type: "ping" });
+ * ```
+ */
+export const createMessageChannel = () => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const channel = new globalThis.MessageChannel();
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        const port1 = disposer.use(wrap(channel.port1));
+        const port2 = disposer.use(wrap(channel.port2));
+        const disposables = disposer.move();
+        return {
+            port1,
+            port2,
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+};
+/**
+ * Creates an Evolu {@link MessagePort} from a Web MessagePort.
+ *
+ * Use this for ports received via postMessage transfer.
+ */
+export const createMessagePort = (nativePort) => wrap(nativePort);
+/** Creates an Evolu {@link BroadcastChannel} from a Web BroadcastChannel. */
+export const createBroadcastChannel = (name) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const nativeBroadcastChannel = new globalThis.BroadcastChannel(name);
+        const disposer = __addDisposableResource(env_2, new DisposableStack(), false);
+        disposer.defer(() => {
+            nativeBroadcastChannel.onmessage = null;
+            nativeBroadcastChannel.close();
+        });
+        const disposables = disposer.move();
+        let onMessageHandler = null;
+        return {
+            postMessage: (message) => {
+                assertNotDisposed(disposables);
+                nativeBroadcastChannel.postMessage(message);
+            },
+            get onMessage() {
+                return disposables.disposed ? null : onMessageHandler;
+            },
+            set onMessage(fn) {
+                if (disposables.disposed)
+                    return;
+                onMessageHandler = fn;
+                nativeBroadcastChannel.onmessage = fn
+                    ? (event) => {
+                        fn(event.data);
+                    }
+                    : null;
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+};
+/**
+ * Creates an Evolu {@link WorkerSelf} from a Web `DedicatedWorkerGlobalScope`
+ * (`self` inside a dedicated worker).
+ */
+export const createWorkerSelf = (nativeSelf) => wrap(nativeSelf);
+/**
+ * Creates an Evolu {@link SharedWorkerSelf} from a Web `SharedWorkerGlobalScope`
+ * (`self` inside a shared worker).
+ *
+ * Disposing closes the shared worker scope for all connected clients.
+ */
+export const createSharedWorkerSelf = (nativeSelf) => {
+    const self = {
+        onConnect: null,
+        [Symbol.dispose]: () => {
+            nativeSelf.onconnect = null;
+            nativeSelf.close();
+        },
+    };
+    nativeSelf.onconnect = (e) => {
+        assert(self.onConnect != null, "onConnect must be set before receiving connections");
+        self.onConnect(wrap(e.ports[0]));
+    };
+    return self;
+};
+/**
+ * Creates a one-tab {@link SharedWorkerSelf} polyfill for browsers without
+ * native SharedWorker support.
+ *
+ * Delivers one synthetic `onConnect` port, queues startup messages until
+ * `onMessage` is set, and does not share state across tabs.
+ */
+export const createOneTabSharedWorkerSelfPolyfill = (nativeSelf) => {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_3, new DisposableStack(), false);
+        let onConnectHandler = null;
+        let onMessageHandler = null;
+        const messages = [];
+        let connected = false;
+        disposer.defer(() => {
+            messages.length = 0;
+            onConnectHandler = null;
+            onMessageHandler = null;
+            nativeSelf.onmessage = null;
+            nativeSelf.close();
+        });
+        const disposables = disposer.move();
+        nativeSelf.onmessage = (event) => {
+            if (disposables.disposed)
+                return;
+            const handler = onMessageHandler;
+            if (handler)
+                handler(event.data);
+            else
+                messages.push(event.data);
+        };
+        const flushMessages = () => {
+            for (const message of messages.splice(0)) {
+                const handler = onMessageHandler;
+                if (!handler)
+                    return;
+                handler(message);
+            }
+        };
+        const port = {
+            postMessage: (message, transfer) => {
+                if (disposables.disposed)
+                    return;
+                if (transfer == null)
+                    nativeSelf.postMessage(message);
+                else
+                    nativeSelf.postMessage(message, [...transfer]);
+            },
+            get onMessage() {
+                return disposables.disposed ? null : onMessageHandler;
+            },
+            set onMessage(fn) {
+                if (disposables.disposed)
+                    return;
+                onMessageHandler = fn;
+                if (fn)
+                    flushMessages();
+            },
+            native: nativeSelf,
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+        const connect = () => {
+            if (connected || !onConnectHandler)
+                return;
+            connected = true;
+            onConnectHandler(port);
+        };
+        return {
+            get onConnect() {
+                return onConnectHandler;
+            },
+            set onConnect(fn) {
+                if (disposables.disposed)
+                    return;
+                onConnectHandler = fn;
+                connect();
+            },
+            [Symbol.dispose]: () => disposables.dispose(),
+        };
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        __disposeResources(env_3);
+    }
+};
+/** Creates deps shared by web worker entry points. */
+export const createWorkerDeps = () => {
+    const consoleStoreOutput = createConsoleStoreOutput();
+    const console = createConsole({ output: consoleStoreOutput });
+    return {
+        console,
+        consoleStoreOutputEntry: consoleStoreOutput.entry,
+        createBroadcastChannel,
+        createMessageChannel,
+        createMessagePort,
+    };
+};
+const wrap = (native) => {
+    let onMessageHandler = null;
+    return {
+        postMessage: (message, transfer) => {
+            if (transfer == null)
+                native.postMessage(message);
+            else
+                native.postMessage(message, [...transfer]);
+        },
+        get onMessage() {
+            return onMessageHandler;
+        },
+        set onMessage(fn) {
+            onMessageHandler = fn;
+            if (fn) {
+                // Messages are queued until onMessage is assigned.
+                native.onmessage = (event) => {
+                    fn(event.data);
+                };
+            }
+            else {
+                native.onmessage = null;
+            }
+        },
+        native: native,
+        [Symbol.dispose]: () => {
+            native.onmessage = null;
+            if ("terminate" in native)
+                native.terminate();
+            else
+                native.close();
+        },
+    };
+};

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./local-first/index.js";
-export * from "./SharedWebWorker.js";
-export * from "./WasmSqliteDriver.js";
-export * from "./WebWorker.js";
+export * from "./Sqlite.js";
+export * from "./Task.js";
+export * from "./Worker.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}