@evolu/web 3.1.0 → 3.1.1

package/README.md

@@ -1,6 +1,12 @@
 # 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.
+This package provides browser-specific Evolu implementations, including
+OPFS-backed SQLite, Web Workers, Shared Workers, and browser platform
+dependencies.
+
+As runtimes increasingly implement the same Web Platform APIs, Evolu's portable
+abstractions for `WebSocket`, `MessagePort`, and Web Locks live in
+`@evolu/common`. Their concrete implementations are supplied by the runtime.
 
 ## Documentation
 

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

@@ -1 +1 @@
-{"version":3,"file":"Platform.d.ts","sourceRoot":"","sources":["../../src/Platform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAE5D,+DAA+D;AAC/D,eAAO,MAAM,eAAe,QAAO,OAMlC,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,QAAO,WACuB,CAAC;AAEhE,eAAO,MAAM,SAAS,EAAE,SAMvB,CAAC"}
+{"version":3,"file":"Platform.d.ts","sourceRoot":"","sources":["../../src/Platform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAE5D,+DAA+D;AAC/D,eAAO,MAAM,eAAe,QAAO,OAIlC,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,QAAO,WACY,CAAC;AAErD,eAAO,MAAM,SAAS,EAAE,SAMvB,CAAC"}

package/dist/src/Platform.js

@@ -1,12 +1,11 @@
 import { PositiveInt } from "@evolu/common";
 /** Returns true when the browser runs on an Apple platform. */
 export const isApplePlatform = () => {
-    const platform = globalThis.navigator.userAgentData?.platform ??
-        globalThis.navigator.platform;
+    const platform = navigator.userAgentData?.platform ?? navigator.platform;
     return /^(?:Mac|iPhone|iPad|iPod)/iu.test(platform);
 };
 /** Returns the amount of logical processors available to the browser. */
-export const availableParallelism = () => PositiveInt.orThrow(globalThis.navigator.hardwareConcurrency);
+export const availableParallelism = () => PositiveInt.orThrow(navigator.hardwareConcurrency);
 export const reloadApp = (url) => {
     if (typeof document === "undefined") {
         return;

package/dist/src/Sqlite.js

@@ -60,7 +60,7 @@ globalThis.sqlite3ApiConfig = {
         if (typeof arg === "string" &&
             arg.startsWith("Ignoring inability to install OPFS sqlite3_vfs"))
             return;
-        // eslint-disable-next-line no-console
+        // oxlint-disable-next-line eslint/no-console
         console.warn(arg);
     },
 };
@@ -96,7 +96,7 @@ export const createWasmSqliteDriver = (name, options) => async () => {
             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
+                // oxlint-disable-next-line typescript/no-unsafe-call
                 sqlite3.capi.sqlite3mc_vfs_create("opfs", 1);
                 const pool = await createOpfsSAHPoolVfs({
                     directory: `.${name}`,

package/dist/src/Task.js

@@ -6,7 +6,7 @@
 import { createRun as createCommonRun, } from "@evolu/common";
 export function createRun(deps) {
     const reportDefect = (reported) => {
-        globalThis.reportError(reported);
+        reportError(reported);
     };
     return deps === undefined
         ? createCommonRun({ reportDefect })

package/dist/src/Worker.d.ts

@@ -39,14 +39,14 @@ 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>;
+export declare const createWorkerSelf: <Input, Output = never>(nativeSelf: 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>;
+export declare const createSharedWorkerSelf: <Input, Output = never>(nativeSelf: SharedWorkerGlobalScope) => SharedWorkerSelf<Input, Output>;
 /**
  * Creates a one-tab {@link SharedWorkerSelf} polyfill for browsers without
  * native SharedWorker support.
@@ -54,7 +54,7 @@ export declare const createSharedWorkerSelf: <Input, Output = never>(nativeSelf:
  * 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>;
+export declare const createOneTabSharedWorkerSelfPolyfill: <Input, Output = never>(nativeSelf: 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

@@ -1 +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,gBAC1B,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,sBAClC,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,sBAwCpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,cACxC,UAAU,CAAC,0BAA0B,KAChD,UAAU,CAAC,KAAK,EAAE,MAAM,CAAoC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,cAC9C,UAAU,CAAC,uBAAuB,KAC7C,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAoBhC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,cAC5D,UAAU,CAAC,0BAA0B,KAChD,gBAAgB,CAAC,KAAK,EAAE,MAAM,CA2EhC,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,gBAAgB,QAAO,UAAU,GAC5C,yBAAyB,GACzB,uBAWD,CAAC"}
+{"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,gBAC1B,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,sBAClC,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,sBAwCpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,cACxC,0BAA0B,KACrC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAoC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,cAC9C,uBAAuB,KAClC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAoBhC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC,GAAI,KAAK,EAAE,MAAM,GAAG,KAAK,cAC5D,0BAA0B,KACrC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CA2EhC,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,gBAAgB,QAAO,UAAU,GAC5C,yBAAyB,GACzB,uBAWD,CAAC"}

package/dist/src/local-first/Db.worker.js

@@ -9,7 +9,7 @@ import { createWorkerDeps, createWorkerSelf } from "../Worker.js";
 const run = createRun({
     ...createWorkerDeps(),
     createSqliteDriver: createWasmSqliteDriver,
-    lockManager: globalThis.navigator.locks,
+    lockManager: navigator.locks,
     randomBytes: createRandomBytes(),
 });
 void run(startDbWorker(createWorkerSelf(self)));

package/dist/src/local-first/Evolu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Evolu.d.ts","sourceRoot":"","sources":["../../../src/local-first/Evolu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,KAAK,EAIV,SAAS,EAGV,MAAM,2BAA2B,CAAC;AAkBnC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;CAC1C;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,yBAAyB,EAAE,MAAM,IAAI,CAAC;CAChD;AAED,uDAAuD;AACvD,eAAO,MAAM,eAAe,UACpB,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,0BAA0B,CAAC,KAC9D,SAkEF,CAAC"}
+{"version":3,"file":"Evolu.d.ts","sourceRoot":"","sources":["../../../src/local-first/Evolu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,KAAK,EAIV,SAAS,EAGV,MAAM,2BAA2B,CAAC;AAiBnC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;CAC1C;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,yBAAyB,EAAE,MAAM,IAAI,CAAC;CAChD;AAED,uDAAuD;AACvD,eAAO,MAAM,eAAe,UACpB,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,0BAA0B,CAAC,KAC9D,SAkEF,CAAC"}

package/dist/src/local-first/Evolu.js

@@ -33,7 +33,7 @@ export const createEvoluDeps = (deps = {}) => {
                                     deps.onSharedWorkerUnsupported();
                                 }
                                 else {
-                                    globalThis.alert("This browser supports Evolu in one tab only. Close this tab and use the already open tab.");
+                                    alert("This browser supports Evolu in one tab only. Close this tab and use the already open tab.");
                                 }
                                 break;
                             }
@@ -50,7 +50,7 @@ export const createEvoluDeps = (deps = {}) => {
         createDbWorker,
         createBroadcastChannel,
         createMessageChannel,
-        lockManager: globalThis.navigator.locks,
+        lockManager: navigator.locks,
         reloadApp,
         sharedWorker,
     });

package/dist/src/local-first/Shared.worker.js

@@ -60,7 +60,7 @@ import { createOneTabSharedWorkerSelfPolyfill, createSharedWorkerSelf, createWor
 const run = createRun({
     ...createWorkerDeps(),
     createWebSocket,
-    lockManager: globalThis.navigator.locks,
+    lockManager: navigator.locks,
 });
 void run(async (run) => {
     const env_1 = { stack: [], error: void 0, hasError: false };
@@ -82,7 +82,7 @@ void run(async (run) => {
             }
         }
         const workerSelf = __addDisposableResource(env_1, createOneTabSharedWorkerSelfPolyfill(self), false);
-        await globalThis.navigator.locks.request("evolu-one-tab-sharedworker-polyfill", { ifAvailable: true, mode: "exclusive" }, async (lock) => {
+        await navigator.locks.request("evolu-one-tab-sharedworker-polyfill", { ifAvailable: true, mode: "exclusive" }, async (lock) => {
             const env_3 = { stack: [], error: void 0, hasError: false };
             try {
                 if (!lock) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/web",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Evolu for web",
   "keywords": [
     "evolu",
@@ -27,6 +27,7 @@
   },
   "files": [
     "dist/src/**",
+    "!dist/**/*.test.*",
     "src/**",
     "README.md"
   ],
@@ -35,13 +36,13 @@
     "idb-keyval": "^6.2.2"
   },
   "devDependencies": {
+    "@evolu/common": "8.8.0",
+    "@evolu/typescript-config": "0.1.1",
     "@types/node": "^24.10.9",
     "@types/sharedworker": "^0.0.229",
     "@types/web-locks-api": "^0.0.5",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "user-agent-data-types": "^0.4.2",
-    "@evolu/common": "8.5.0",
-    "@evolu/typescript-config": "0.0.2"
+    "user-agent-data-types": "^0.4.2"
   },
   "peerDependencies": {
     "@evolu/common": "^8.0.0"
@@ -50,7 +51,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=24.20.0"
   },
   "sideEffects": false,
   "scripts": {

package/src/Platform.test.ts

@@ -0,0 +1,45 @@
+import {
+  assertEqual,
+  assertFalse,
+  assertTrue,
+  assertType,
+  PositiveInt,
+  testStubGlobal,
+} from "@evolu/common";
+import { test } from "node:test";
+import { availableParallelism, isApplePlatform } from "./index.ts";
+
+for (const platform of ["macOS", "MacIntel", "iPhone", "iPad", "iPod"]) {
+  test(`isApplePlatform recognizes ${platform}`, () => {
+    using _navigator = testStubGlobal("navigator", {
+      platform: "Win32",
+      userAgentData: { platform },
+    });
+
+    assertTrue(isApplePlatform());
+  });
+}
+
+test("isApplePlatform recognizes a non-Apple platform", () => {
+  using _navigator = testStubGlobal("navigator", {
+    platform: "MacIntel",
+    userAgentData: { platform: "Windows" },
+  });
+
+  assertFalse(isApplePlatform());
+});
+
+test("isApplePlatform falls back to navigator.platform", () => {
+  using _navigator = testStubGlobal("navigator", { platform: "MacIntel" });
+
+  assertTrue(isApplePlatform());
+});
+
+test("availableParallelism returns the validated browser value", () => {
+  using _navigator = testStubGlobal("navigator", { hardwareConcurrency: 128 });
+
+  const parallelism = availableParallelism();
+
+  assertType<typeof parallelism, PositiveInt>();
+  assertEqual(parallelism, 128);
+});

package/src/Platform.ts

@@ -2,16 +2,14 @@ import { PositiveInt, type ReloadApp } from "@evolu/common";
 
 /** Returns true when the browser runs on an Apple platform. */
 export const isApplePlatform = (): boolean => {
-  const platform =
-    globalThis.navigator.userAgentData?.platform ??
-    globalThis.navigator.platform;
+  const platform = navigator.userAgentData?.platform ?? navigator.platform;
 
   return /^(?:Mac|iPhone|iPad|iPod)/iu.test(platform);
 };
 
 /** Returns the amount of logical processors available to the browser. */
 export const availableParallelism = (): PositiveInt =>
-  PositiveInt.orThrow(globalThis.navigator.hardwareConcurrency);
+  PositiveInt.orThrow(navigator.hardwareConcurrency);
 
 export const reloadApp: ReloadApp = (url) => {
   if (typeof document === "undefined") {

package/src/Sqlite.test.ts

@@ -0,0 +1,356 @@
+import {
+  assertEqual,
+  assertEqualBytes,
+  assertTrue,
+  EncryptionKey,
+  Name,
+  sql,
+  testCreateRun,
+} from "@evolu/common";
+import { describe, it, mock } from "node:test";
+
+const sqliteMock = (() => {
+  class PreparedStatement {
+    finalized = false;
+    resetCount = 0;
+    stepCount = 0;
+    readonly bound: Array<ReadonlyArray<unknown>> = [];
+
+    bind(parameters: ReadonlyArray<unknown>): void {
+      this.bound.push(parameters);
+    }
+
+    step(): boolean {
+      this.stepCount += 1;
+      return this.stepCount === 1;
+    }
+
+    get(): Record<string, unknown> {
+      return { data: "prepared" };
+    }
+
+    reset(): void {
+      this.resetCount += 1;
+    }
+
+    finalize(): void {
+      this.finalized = true;
+    }
+  }
+
+  class Database {
+    readonly execSql: Array<string> = [];
+    readonly filename: string;
+
+    constructor(filename: string) {
+      this.filename = filename;
+      state.createdDatabases.push(this);
+    }
+
+    prepare(): PreparedStatement {
+      const statement = new PreparedStatement();
+      state.preparedStatements.push(statement);
+      return statement;
+    }
+
+    exec(sql: string): ReadonlyArray<Record<string, unknown>> {
+      this.execSql.push(sql);
+      return [{ data: "row" }];
+    }
+
+    changes(): number {
+      return 1;
+    }
+
+    close(): void {
+      state.closedDatabases.push(this.filename);
+      state.events.push(`close:${this.filename}`);
+    }
+  }
+
+  const state = {
+    closedDatabases: [] as Array<string>,
+    createdDatabases: [] as Array<Database>,
+    deletedFilenames: [] as Array<string>,
+    events: [] as Array<string>,
+    pausedVfsNames: [] as Array<string>,
+    preparedStatements: [] as Array<PreparedStatement>,
+    unpausedVfsNames: [] as Array<string>,
+  };
+
+  let poolPaused = false;
+  const pool = {
+    isPaused: mock.fn(() => poolPaused),
+    OpfsSAHPoolDb: Database,
+    pauseVfs: mock.fn(() => {
+      poolPaused = true;
+      state.pausedVfsNames.push(pool.vfsName);
+      state.events.push(`pause:${pool.vfsName}`);
+      return pool;
+    }),
+    unpauseVfs: mock.fn(() => {
+      poolPaused = false;
+      state.unpausedVfsNames.push(pool.vfsName);
+      state.events.push(`unpause:${pool.vfsName}`);
+      return Promise.resolve(pool);
+    }),
+    unlink: mock.fn((filename: string) => {
+      state.deletedFilenames.push(filename);
+      state.events.push(`unlink:${filename}`);
+      return true;
+    }),
+    vfsName: "mock-sahpool",
+  };
+
+  const sqlite3 = {
+    capi: {
+      sqlite3_js_db_export: mock.fn(() => new Uint8Array([1, 2, 3])),
+      sqlite3mc_vfs_create: mock.fn(),
+    },
+    installOpfsSAHPoolVfs: mock.fn(() => Promise.resolve(pool)),
+    oo1: { DB: Database },
+  };
+
+  return {
+    consoleWarn: mock.fn<typeof console.warn>(),
+    pool,
+    reset: () => {
+      state.closedDatabases.length = 0;
+      state.createdDatabases.length = 0;
+      state.deletedFilenames.length = 0;
+      state.events.length = 0;
+      state.pausedVfsNames.length = 0;
+      state.preparedStatements.length = 0;
+      state.unpausedVfsNames.length = 0;
+      poolPaused = false;
+      pool.isPaused.mock.resetCalls();
+      pool.pauseVfs.mock.resetCalls();
+      pool.unpauseVfs.mock.resetCalls();
+      pool.unlink.mock.resetCalls();
+      sqlite3.capi.sqlite3_js_db_export.mock.resetCalls();
+      sqlite3.capi.sqlite3mc_vfs_create.mock.resetCalls();
+      sqlite3.installOpfsSAHPoolVfs.mock.resetCalls();
+    },
+    sqlite3,
+    state,
+  };
+})();
+
+mock.module("@evolu/sqlite-wasm", {
+  // @ts-expect-error -- Node.js 24.20 replaces the deprecated defaultExport option with exports, which @types/node 24.13 does not declare yet.
+  exports: {
+    default: mock.fn(() => {
+      const config = Reflect.get(globalThis, "sqlite3ApiConfig") as
+        | {
+            readonly warn?: (arg: unknown) => void;
+          }
+        | undefined;
+      config?.warn?.("Ignoring inability to install OPFS sqlite3_vfs");
+      config?.warn?.("kept warning");
+      return Promise.resolve(sqliteMock.sqlite3);
+    }),
+  },
+});
+
+mock.method(console, "warn", sqliteMock.consoleWarn);
+const { createWasmSqliteDriver } = await import("./Sqlite.ts");
+
+describe("createWasmSqliteDriver coverage helpers", () => {
+  it("filters sqlite init warnings", () => {
+    assertEqual(
+      sqliteMock.consoleWarn.mock.calls.map(({ arguments: args }) => args),
+      [["kept warning"]],
+    );
+  });
+
+  it("opens plain OPFS SAH-pool database", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    using _driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockPlain")),
+    );
+
+    assertEqual(
+      sqliteMock.sqlite3.installOpfsSAHPoolVfs.mock.calls.map(
+        ({ arguments: args }) => args,
+      ),
+      [[{ name: "MockPlain" }]],
+    );
+    assertEqual(
+      sqliteMock.state.createdDatabases[0]?.filename,
+      "file:evolu1.db",
+    );
+  });
+
+  it("opens memory database", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    using _driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockMemory"), { mode: "memory" }),
+    );
+
+    assertEqual(sqliteMock.sqlite3.installOpfsSAHPoolVfs.mock.callCount(), 0);
+    assertEqual(sqliteMock.state.createdDatabases[0]?.filename, ":memory:");
+  });
+
+  it("executes non-prepared query and exports database", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    using driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockPlain")),
+    );
+
+    const result = driver.exec(sql`select ${"row"};`);
+    const exported = driver.export();
+
+    assertEqual(result, { rows: [{ data: "row" }], changes: 1 });
+    assertEqualBytes(exported, [1, 2, 3]);
+  });
+
+  it("executes prepared query and finalizes statement on dispose", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    {
+      using driver = await run.ok(
+        createWasmSqliteDriver(Name.orThrow("MockPlain")),
+      );
+
+      const result = driver.exec({
+        ...sql`select ${"prepared"};`,
+        options: { prepare: true },
+      });
+
+      assertEqual(result, { rows: [{ data: "prepared" }], changes: 1 });
+
+      driver.exec({ ...sql`select 1;`, options: { prepare: true } });
+    }
+
+    assertEqual(sqliteMock.state.preparedStatements[0]?.bound, [["prepared"]]);
+    assertEqual(sqliteMock.state.preparedStatements[0]?.resetCount, 1);
+    assertEqual(sqliteMock.state.preparedStatements[0]?.finalized, true);
+    assertEqual(sqliteMock.state.preparedStatements[1]?.bound, []);
+    assertEqual(sqliteMock.state.preparedStatements[1]?.finalized, true);
+  });
+
+  it("closes OPFS database on dispose", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    {
+      using _driver = await run.ok(
+        createWasmSqliteDriver(Name.orThrow("MockPlain")),
+      );
+    }
+
+    assertEqual(sqliteMock.state.closedDatabases, ["file:evolu1.db"]);
+    assertEqual(sqliteMock.state.pausedVfsNames, ["mock-sahpool"]);
+    assertEqual(sqliteMock.pool.unlink.mock.callCount(), 0);
+  });
+
+  it("unpauses OPFS SAH-pool database on reopen", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    {
+      using _driver = await run.ok(
+        createWasmSqliteDriver(Name.orThrow("MockPlain")),
+      );
+    }
+
+    using _driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockPlain")),
+    );
+
+    assertEqual(sqliteMock.state.unpausedVfsNames, ["mock-sahpool"]);
+  });
+
+  it("deletes plain OPFS database file", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    using driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockPlain")),
+    );
+
+    driver.deleteDatabase();
+
+    assertEqual(sqliteMock.state.closedDatabases, ["file:evolu1.db"]);
+    assertEqual(sqliteMock.state.deletedFilenames, ["/evolu1.db"]);
+    assertEqual(sqliteMock.state.events, [
+      "close:file:evolu1.db",
+      "unlink:/evolu1.db",
+      "pause:mock-sahpool",
+    ]);
+  });
+
+  it("deletes memory database", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    using driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockMemory"), { mode: "memory" }),
+    );
+
+    driver.deleteDatabase();
+
+    assertEqual(sqliteMock.state.events, ["close::memory:"]);
+    assertEqual(sqliteMock.pool.unlink.mock.callCount(), 0);
+    assertEqual(sqliteMock.pool.pauseVfs.mock.callCount(), 0);
+  });
+
+  it("deletes encrypted OPFS database file", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    using driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockEncrypted"), {
+        mode: "encrypted",
+        encryptionKey: EncryptionKey.orThrow(new Uint8Array(32).fill(42)),
+      }),
+    );
+
+    driver.deleteDatabase();
+
+    assertEqual(sqliteMock.state.closedDatabases, [
+      "file:evolu1.db?vfs=multipleciphers-opfs-sahpool",
+    ]);
+    assertEqual(sqliteMock.state.deletedFilenames, ["/evolu1.db"]);
+    assertEqual(sqliteMock.state.events, [
+      "close:file:evolu1.db?vfs=multipleciphers-opfs-sahpool",
+      "unlink:/evolu1.db",
+      "pause:mock-sahpool",
+    ]);
+  });
+
+  it("configures encrypted OPFS database", async () => {
+    sqliteMock.reset();
+
+    await using run = testCreateRun();
+    using _driver = await run.ok(
+      createWasmSqliteDriver(Name.orThrow("MockEncrypted"), {
+        mode: "encrypted",
+        encryptionKey: EncryptionKey.orThrow(new Uint8Array(32).fill(42)),
+      }),
+    );
+
+    assertEqual(
+      sqliteMock.sqlite3.installOpfsSAHPoolVfs.mock.calls.map(
+        ({ arguments: args }) => args,
+      ),
+      [[{ directory: ".MockEncrypted" }]],
+    );
+    assertEqual(
+      sqliteMock.state.createdDatabases[0]?.filename,
+      "file:evolu1.db?vfs=multipleciphers-opfs-sahpool",
+    );
+    assertTrue(
+      sqliteMock.state.createdDatabases[0]?.execSql[0]?.includes(
+        "PRAGMA cipher = 'sqlcipher';",
+      ),
+    );
+  });
+});

package/src/Sqlite.ts

@@ -21,7 +21,7 @@ globalThis.sqlite3ApiConfig = {
       arg.startsWith("Ignoring inability to install OPFS sqlite3_vfs")
     )
       return;
-    // eslint-disable-next-line no-console
+    // oxlint-disable-next-line eslint/no-console
     console.warn(arg);
   },
 };
@@ -65,7 +65,7 @@ export const createWasmSqliteDriver: CreateSqliteDriver =
       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
+        // oxlint-disable-next-line typescript/no-unsafe-call
         sqlite3.capi.sqlite3mc_vfs_create("opfs", 1);
         const pool = await createOpfsSAHPoolVfs({
           directory: `.${name}`,

package/src/Task.test.ts

@@ -0,0 +1,51 @@
+import {
+  assertEqual,
+  assertNonNullable,
+  assertTrue,
+  testStubGlobal,
+} from "@evolu/common";
+import { describe, it, mock } from "node:test";
+import { createRun } from "./Task.ts";
+
+describe("createRun", () => {
+  it("createRun reports defects with global reportError", async () => {
+    const reportError = mock.fn<(error: unknown) => void>();
+    using _reportError = testStubGlobal("reportError", reportError);
+    await using run = createRun();
+    const defect = new Error("boom");
+
+    run.panic(defect);
+
+    assertEqual(reportError.mock.callCount(), 1);
+    const reported = reportError.mock.calls[0]?.arguments[0];
+    assertNonNullable(reported);
+    assertTrue(typeof reported === "object");
+    assertEqual(Reflect.get(reported, "reason"), {
+      type: "PanicAbortReason",
+      defect,
+    });
+  });
+
+  it("createRun preserves a custom reportDefect", async () => {
+    const reportError = mock.fn();
+    const reportDefect = mock.fn();
+    using _reportError = testStubGlobal("reportError", reportError);
+    await using run = createRun({ reportDefect });
+    const defect = new Error("boom");
+
+    run.panic(defect);
+
+    assertEqual(reportDefect.mock.callCount(), 1);
+    assertEqual(reportError.mock.callCount(), 0);
+  });
+
+  it("merges custom deps", async () => {
+    interface CustomDep {
+      readonly customValue: number;
+    }
+
+    await using run = createRun<CustomDep>({ customValue: 42 });
+
+    assertEqual(run.deps.customValue, 42);
+  });
+});

package/src/Task.ts

@@ -49,7 +49,7 @@ export function createRun<D extends object>(
   deps?: RunCustomDeps<D>,
 ): DisposableRun | DisposableRun<D> {
   const reportDefect = (reported: unknown): void => {
-    globalThis.reportError(reported);
+    reportError(reported);
   };
 
   return deps === undefined

package/src/Worker.test.ts

@@ -0,0 +1,473 @@
+import {
+  assertEqual,
+  assertNonNullable,
+  assertSame,
+  assertThrowsInstanceOf,
+  testStubGlobal,
+  type MessagePort,
+  type NativeMessagePort,
+} from "@evolu/common";
+import { describe, it, mock, test } from "node:test";
+import {
+  createBroadcastChannel,
+  createOneTabSharedWorkerSelfPolyfill,
+  createMessageChannel,
+  createMessagePort,
+  createSharedWorker,
+  createSharedWorkerSelf,
+  createWorker,
+  createWorkerDeps,
+  createWorkerSelf,
+  installOneTabSharedWorkerPolyfill,
+} from "./Worker.ts";
+
+test("createWorker wraps a native worker and disposes via terminate", () => {
+  const nativeWorker = {
+    onmessage: null as ((event: MessageEvent<string>) => void) | null,
+    postMessage:
+      mock.fn<
+        (message: unknown, transfer?: ReadonlyArray<Transferable>) => void
+      >(),
+    terminate: mock.fn(),
+  };
+  const worker = createWorker<string, string>(
+    nativeWorker as unknown as Worker,
+  );
+  const received: Array<string> = [];
+
+  worker.onMessage = (message) => {
+    received.push(message);
+  };
+  nativeWorker.onmessage?.({ data: "response" } as MessageEvent<string>);
+  worker.postMessage("request");
+  worker[Symbol.dispose]();
+
+  assertEqual(received, ["response"]);
+  assertSame(worker.native, nativeWorker);
+  assertEqual(
+    nativeWorker.postMessage.mock.calls.map(({ arguments: args }) => args),
+    [["request"]],
+  );
+  assertEqual(nativeWorker.terminate.mock.callCount(), 1);
+  assertEqual(nativeWorker.onmessage, null);
+});
+
+test("createMessageChannel queues messages until onMessage is assigned", async () => {
+  using channel = createMessageChannel<string>();
+  const received: Array<string> = [];
+  const delivered = Promise.withResolvers<void>();
+
+  channel.port1.postMessage("queued");
+  channel.port2.onMessage = (message) => {
+    received.push(message);
+    delivered.resolve();
+  };
+
+  await delivered.promise;
+  assertEqual(received, ["queued"]);
+});
+
+test("createMessageChannel supports bidirectional communication and disposal", async () => {
+  using channel = createMessageChannel<string, number>();
+  const strings: Array<string> = [];
+  const numbers: Array<number> = [];
+  const stringDelivered = Promise.withResolvers<void>();
+  const numberDelivered = Promise.withResolvers<void>();
+
+  channel.port2.onMessage = (message) => {
+    strings.push(message);
+    stringDelivered.resolve();
+  };
+  channel.port1.onMessage = (message) => {
+    numbers.push(message);
+    numberDelivered.resolve();
+  };
+
+  channel.port1.postMessage("hello");
+  channel.port2.postMessage(42);
+
+  await Promise.all([stringDelivered.promise, numberDelivered.promise]);
+  assertEqual(strings, ["hello"]);
+  assertEqual(numbers, [42]);
+});
+
+test("createMessagePort wraps a native port received from MessageChannel", async () => {
+  using disposer = new DisposableStack();
+  const nativeChannel = new MessageChannel();
+  disposer.defer(() => {
+    nativeChannel.port2.close();
+  });
+  const wrappedPort = disposer.use(
+    createMessagePort<number, string>(
+      nativeChannel.port1 as unknown as NativeMessagePort<number, string>,
+    ),
+  );
+  const received: Array<string> = [];
+  const delivered = Promise.withResolvers<void>();
+
+  wrappedPort.onMessage = (message) => {
+    received.push(message);
+    delivered.resolve();
+  };
+  nativeChannel.port2.postMessage("hello");
+
+  await delivered.promise;
+  assertEqual(received, ["hello"]);
+
+  const nativeReceived = new Promise<number>((resolve) => {
+    // oxlint-disable-next-line unicorn/prefer-add-event-listener -- Assigning onmessage also starts this MessagePort automatically.
+    nativeChannel.port2.onmessage = (event) => {
+      resolve(event.data as number);
+    };
+  });
+
+  wrappedPort.postMessage(42);
+
+  assertEqual(await nativeReceived, 42);
+});
+
+test("createMessagePort assigns and clears the native onmessage handler", () => {
+  const nativePort = createClosableNativePort<string>();
+  const wrappedPort = createMessagePort<string, string>(
+    nativePort as unknown as NativeMessagePort<string, string>,
+  );
+  const transferable = new ArrayBuffer(1);
+  const received: Array<string> = [];
+
+  wrappedPort.onMessage = (message) => {
+    received.push(message);
+  };
+  nativePort.onmessage?.({ data: "response" } as MessageEvent<string>);
+  wrappedPort.postMessage("without transfer");
+  wrappedPort.postMessage("with transfer", [transferable]);
+  wrappedPort.onMessage = null;
+
+  assertEqual(received, ["response"]);
+  assertEqual(nativePort.onmessage, null);
+  assertEqual(wrappedPort.onMessage, null);
+  assertEqual(
+    nativePort.postMessage.mock.calls.map(({ arguments: args }) => args),
+    [["without transfer"], ["with transfer", [transferable]]],
+  );
+});
+
+test("createBroadcastChannel wraps native BroadcastChannel", async () => {
+  const channelName = `test-channel-${crypto.randomUUID()}`;
+  const channel1 = createBroadcastChannel<string>(channelName);
+  const received1: Array<string> = [];
+  const received2: Array<string> = [];
+  const delivered = Promise.withResolvers<void>();
+
+  {
+    using _channel1 = channel1;
+    using channel2 = createBroadcastChannel<string>(channelName);
+
+    channel1.onMessage = (message) => {
+      received1.push(message);
+    };
+    channel2.onMessage = (message) => {
+      received2.push(message);
+    };
+    assertNonNullable(channel2.onMessage);
+    channel2.onMessage = null;
+    assertEqual(channel2.onMessage, null);
+    channel2.onMessage = (message) => {
+      received2.push(message);
+      delivered.resolve();
+    };
+
+    channel1.postMessage("hello");
+
+    await delivered.promise;
+    assertEqual(received2, ["hello"]);
+
+    assertEqual(received1, []);
+  }
+
+  channel1.onMessage = (message) => {
+    received1.push(message);
+  };
+  assertEqual(channel1.onMessage, null);
+  const error = assertThrowsInstanceOf(
+    () => channel1.postMessage("closed"),
+    Error,
+  );
+  assertEqual(error.message, "Cannot use a disposed object.");
+});
+
+test("createMessagePort dispose uses terminate when available", () => {
+  const nativePort = {
+    onmessage: null as ((event: MessageEvent<string>) => void) | null,
+    postMessage:
+      mock.fn<
+        (message: unknown, transfer?: ReadonlyArray<Transferable>) => void
+      >(),
+    terminate: mock.fn(),
+  };
+
+  const wrappedPort = createMessagePort(
+    nativePort as unknown as NativeMessagePort<string>,
+  );
+
+  wrappedPort[Symbol.dispose]();
+
+  assertEqual(nativePort.onmessage, null);
+  assertEqual(nativePort.terminate.mock.callCount(), 1);
+});
+
+test("createSharedWorker wraps a shared worker port and disposes via close", () => {
+  const nativePort = createClosableNativePort<string>();
+  const nativeSharedWorker = { port: nativePort };
+  const worker = createSharedWorker<string, string>(
+    nativeSharedWorker as unknown as SharedWorker,
+  );
+  const received: Array<string> = [];
+
+  worker.port.onMessage = (message) => {
+    received.push(message);
+  };
+  nativePort.onmessage?.({ data: "response" } as MessageEvent<string>);
+  worker.port.postMessage("request");
+  worker[Symbol.dispose]();
+
+  assertEqual(received, ["response"]);
+  assertSame(worker.port.native, nativePort);
+  assertEqual(
+    nativePort.postMessage.mock.calls.map(({ arguments: args }) => args),
+    [["request"]],
+  );
+  assertEqual(nativePort.close.mock.callCount(), 1);
+  assertEqual(nativePort.onmessage, null);
+});
+
+describe("one-tab SharedWorker polyfill", () => {
+  it("installOneTabSharedWorkerPolyfill installs a Worker-backed SharedWorker", () => {
+    const nativeWorker = createClosableNativePort<string>();
+    const calls: Array<{
+      readonly scriptURL: string | URL;
+      readonly options: WorkerOptions | undefined;
+    }> = [];
+    const Worker = function (scriptURL: string | URL, options?: WorkerOptions) {
+      calls.push({ scriptURL, options });
+      return nativeWorker;
+    } as unknown as typeof globalThis.Worker;
+    const scriptURL = new URL("https://example.com/Shared.worker.js");
+    const options = { type: "module" } as const;
+
+    using _sharedWorker = testStubGlobal("SharedWorker", undefined);
+    using _worker = testStubGlobal("Worker", Worker);
+
+    installOneTabSharedWorkerPolyfill();
+    const nativeSharedWorker = new SharedWorker(scriptURL, options);
+
+    assertEqual(calls, [{ scriptURL, options }]);
+    assertSame(nativeSharedWorker.port, nativeWorker);
+  });
+
+  it("installOneTabSharedWorkerPolyfill keeps native SharedWorker", () => {
+    const nativePort = createClosableNativePort<string>();
+    const NativeSharedWorker = class {
+      readonly port = nativePort;
+    } as unknown as typeof SharedWorker;
+
+    using _sharedWorker = testStubGlobal("SharedWorker", NativeSharedWorker);
+
+    installOneTabSharedWorkerPolyfill();
+    assertSame(SharedWorker, NativeSharedWorker);
+  });
+
+  it("createOneTabSharedWorkerSelfPolyfill creates one queued synthetic connection", () => {
+    const nativeSelf = createClosableNativePort<string>();
+    const workerSelf = createOneTabSharedWorkerSelfPolyfill<string, string>(
+      nativeSelf as unknown as DedicatedWorkerGlobalScope,
+    );
+    const received: Array<string> = [];
+    let connectedPort!: MessagePort<string, string>;
+
+    assertEqual(workerSelf.onConnect, null);
+    workerSelf.onConnect = null;
+    workerSelf.onConnect = (port) => {
+      connectedPort = port;
+    };
+    assertNonNullable(workerSelf.onConnect);
+
+    nativeSelf.onmessage?.({ data: "queued" } as MessageEvent<string>);
+    connectedPort.onMessage = (message) => {
+      received.push(message);
+    };
+    assertNonNullable(connectedPort.onMessage);
+
+    nativeSelf.onmessage?.({ data: "immediate" } as MessageEvent<string>);
+    connectedPort.onMessage = null;
+    assertEqual(connectedPort.onMessage, null);
+    connectedPort.onMessage = (message) => {
+      received.push(message);
+    };
+    workerSelf.onConnect = null;
+
+    connectedPort.postMessage("response");
+    const transferable = new ArrayBuffer(1);
+    connectedPort.postMessage("response with transfer", [transferable]);
+    const nativeSelfOnMessage = nativeSelf.onmessage;
+    workerSelf[Symbol.dispose]();
+    nativeSelfOnMessage?.({ data: "ignored" } as MessageEvent<string>);
+    connectedPort.postMessage("ignored");
+    connectedPort.onMessage = () => {
+      received.push("ignored");
+    };
+    workerSelf[Symbol.dispose]();
+
+    assertEqual(received, ["queued", "immediate"]);
+    assertSame(connectedPort.native, nativeSelf);
+    assertEqual(connectedPort.onMessage, null);
+    assertEqual(
+      nativeSelf.postMessage.mock.calls.map(({ arguments: args }) => args),
+      [["response"], ["response with transfer", [transferable]]],
+    );
+    assertEqual(nativeSelf.close.mock.callCount(), 1);
+    assertEqual(nativeSelf.onmessage, null);
+  });
+
+  it("createOneTabSharedWorkerSelfPolyfill stops flushing when onMessage is cleared", () => {
+    const nativeSelf = createClosableNativePort<string>();
+    const workerSelf = createOneTabSharedWorkerSelfPolyfill<string, string>(
+      nativeSelf as unknown as DedicatedWorkerGlobalScope,
+    );
+    const received: Array<string> = [];
+    let connectedPort!: MessagePort<string, string>;
+
+    workerSelf.onConnect = (port) => {
+      connectedPort = port;
+    };
+    nativeSelf.onmessage?.({ data: "first" } as MessageEvent<string>);
+    nativeSelf.onmessage?.({ data: "second" } as MessageEvent<string>);
+    connectedPort.onMessage = (message) => {
+      received.push(message);
+      connectedPort.onMessage = null;
+    };
+    workerSelf[Symbol.dispose]();
+
+    assertEqual(received, ["first"]);
+  });
+
+  it("createOneTabSharedWorkerSelfPolyfill disposes from connected port", () => {
+    const nativeSelf = createClosableNativePort<string>();
+    const workerSelf = createOneTabSharedWorkerSelfPolyfill<string, string>(
+      nativeSelf as unknown as DedicatedWorkerGlobalScope,
+    );
+    let connectedPort!: MessagePort<string, string>;
+
+    workerSelf.onConnect = (port) => {
+      connectedPort = port;
+    };
+
+    connectedPort[Symbol.dispose]();
+    workerSelf.onConnect = () => {
+      throw new Error("Disposed worker self must ignore onConnect setter.");
+    };
+
+    assertEqual(workerSelf.onConnect, null);
+    assertEqual(connectedPort.onMessage, null);
+    assertEqual(nativeSelf.close.mock.callCount(), 1);
+    assertEqual(nativeSelf.onmessage, null);
+  });
+});
+
+test("createWorkerSelf wraps dedicated worker self and disposes via close", () => {
+  const nativeSelf = createClosableNativePort<string>();
+  const workerSelf = createWorkerSelf<string, string>(
+    nativeSelf as unknown as DedicatedWorkerGlobalScope,
+  );
+  const received: Array<string> = [];
+
+  workerSelf.onMessage = (message) => {
+    received.push(message);
+  };
+  nativeSelf.onmessage?.({ data: "request" } as MessageEvent<string>);
+  workerSelf.postMessage("response");
+  workerSelf[Symbol.dispose]();
+
+  assertEqual(received, ["request"]);
+  assertEqual(
+    nativeSelf.postMessage.mock.calls.map(({ arguments: args }) => args),
+    [["response"]],
+  );
+  assertEqual(nativeSelf.close.mock.callCount(), 1);
+});
+
+test("createSharedWorkerSelf wraps connected ports and disposes the worker scope", () => {
+  const nativePort = createClosableNativePort<string>();
+  const nativeSelf = {
+    close: mock.fn(),
+    onconnect: null as ((event: MessageEvent) => void) | null,
+  };
+  const workerSelf = createSharedWorkerSelf<string, string>(
+    nativeSelf as unknown as SharedWorkerGlobalScope,
+  );
+  const received: Array<string> = [];
+  let connectedPort!: MessagePort<string, string>;
+
+  workerSelf.onConnect = (port) => {
+    connectedPort = port;
+  };
+  nativeSelf.onconnect?.({ ports: [nativePort] } as unknown as MessageEvent);
+
+  connectedPort.onMessage = (message) => {
+    received.push(message);
+  };
+  nativePort.onmessage?.({ data: "request" } as MessageEvent<string>);
+  connectedPort.postMessage("response");
+  connectedPort[Symbol.dispose]();
+  workerSelf[Symbol.dispose]();
+
+  assertEqual(received, ["request"]);
+  assertSame(connectedPort.native, nativePort);
+  assertEqual(
+    nativePort.postMessage.mock.calls.map(({ arguments: args }) => args),
+    [["response"]],
+  );
+  assertEqual(nativePort.close.mock.callCount(), 1);
+  assertEqual(nativeSelf.onconnect, null);
+  assertEqual(nativeSelf.close.mock.callCount(), 1);
+});
+
+test("createSharedWorkerSelf asserts when a connection arrives before onConnect is set", () => {
+  const nativeSelf = {
+    close: mock.fn(),
+    onconnect: null as ((event: MessageEvent) => void) | null,
+  };
+
+  createSharedWorkerSelf<string, string>(
+    nativeSelf as unknown as SharedWorkerGlobalScope,
+  );
+
+  const error = assertThrowsInstanceOf(() => {
+    nativeSelf.onconnect?.({ ports: [] } as unknown as MessageEvent);
+  }, Error);
+  assertEqual(
+    error.message,
+    "onConnect must be set before receiving connections",
+  );
+});
+
+test("createWorkerDeps stores console output entries and exposes createMessagePort", () => {
+  const deps = createWorkerDeps();
+
+  deps.console.warn("worker-warning");
+
+  assertSame(deps.createMessagePort, createMessagePort);
+  assertEqual(deps.consoleStoreOutputEntry.get(), {
+    args: ["worker-warning"],
+    method: "warn",
+    path: [],
+  });
+});
+
+const createClosableNativePort = <Output = never>() => ({
+  close: mock.fn(),
+  onmessage: null as ((event: MessageEvent<Output>) => void) | null,
+  postMessage:
+    mock.fn<
+      (message: unknown, transfer?: ReadonlyArray<Transferable>) => void
+    >(),
+});

package/src/Worker.ts

@@ -152,7 +152,7 @@ export const createBroadcastChannel: CreateBroadcastChannel = <
  * (`self` inside a dedicated worker).
  */
 export const createWorkerSelf = <Input, Output = never>(
-  nativeSelf: globalThis.DedicatedWorkerGlobalScope,
+  nativeSelf: DedicatedWorkerGlobalScope,
 ): WorkerSelf<Input, Output> => wrap<Output, Input>(nativeSelf);
 
 /**
@@ -162,7 +162,7 @@ export const createWorkerSelf = <Input, Output = never>(
  * Disposing closes the shared worker scope for all connected clients.
  */
 export const createSharedWorkerSelf = <Input, Output = never>(
-  nativeSelf: globalThis.SharedWorkerGlobalScope,
+  nativeSelf: SharedWorkerGlobalScope,
 ): SharedWorkerSelf<Input, Output> => {
   const self: SharedWorkerSelf<Input, Output> = {
     onConnect: null,
@@ -193,7 +193,7 @@ export const createSharedWorkerSelf = <Input, Output = never>(
  * `onMessage` is set, and does not share state across tabs.
  */
 export const createOneTabSharedWorkerSelfPolyfill = <Input, Output = never>(
-  nativeSelf: globalThis.DedicatedWorkerGlobalScope,
+  nativeSelf: DedicatedWorkerGlobalScope,
 ): SharedWorkerSelf<Input, Output> => {
   using disposer = new DisposableStack();
 

package/src/local-first/Db.worker.ts

@@ -13,7 +13,7 @@ import { createWorkerDeps, createWorkerSelf } from "../Worker.ts";
 const run = createRun({
   ...createWorkerDeps(),
   createSqliteDriver: createWasmSqliteDriver,
-  lockManager: globalThis.navigator.locks,
+  lockManager: navigator.locks,
   randomBytes: createRandomBytes(),
 });
 

package/src/local-first/Evolu.test.ts

@@ -0,0 +1,50 @@
+import {
+  assertEqual,
+  assertNonNullable,
+  testStubGlobal,
+  type NativeMessagePort,
+} from "@evolu/common";
+import { describe, it, mock } from "node:test";
+import { createEvoluDeps } from "./Evolu.ts";
+
+describe("createEvoluDeps", () => {
+  it("createEvoluDeps calls callback when one-tab SharedWorker polyfill is already open", () => {
+    const nativeSharedWorkerPort = createClosableNativePort<unknown>();
+    const nativeDbWorker = createClosableNativePort();
+    const onSharedWorkerUnsupported = mock.fn<() => void>();
+
+    using _sharedWorker = testStubGlobal(
+      "SharedWorker",
+      class {
+        readonly port = nativeSharedWorkerPort as unknown as NativeMessagePort<
+          never,
+          unknown
+        >;
+      },
+    );
+    const Worker = mock.fn(function () {
+      return nativeDbWorker;
+    });
+    using _worker = testStubGlobal("Worker", Worker);
+
+    using deps = createEvoluDeps({
+      onSharedWorkerUnsupported,
+    });
+
+    nativeSharedWorkerPort.onmessage?.(
+      new MessageEvent("message", {
+        data: { type: "SharedWorkerUnsupported" },
+      }),
+    );
+
+    assertEqual(onSharedWorkerUnsupported.mock.callCount(), 1);
+    assertEqual(Worker.mock.callCount(), 0);
+    assertNonNullable(deps);
+  });
+});
+
+const createClosableNativePort = <Output = never>() => ({
+  close: mock.fn(),
+  onmessage: null as ((event: MessageEvent<Output>) => void) | null,
+  postMessage: mock.fn(),
+});

package/src/local-first/Evolu.ts

@@ -18,7 +18,6 @@ import {
 } from "../Worker.ts";
 
 // // TODO: Redesign.
-// // eslint-disable-next-line evolu/require-pure-annotation
 // export const localAuth = createLocalAuth({
 //   randomBytes: createRandomBytes(),
 //   secureStorage: createWebAuthnStore({ randomBytes: createRandomBytes() }),
@@ -76,7 +75,7 @@ export const createEvoluDeps = (
                   if (deps.onSharedWorkerUnsupported) {
                     deps.onSharedWorkerUnsupported();
                   } else {
-                    globalThis.alert(
+                    alert(
                       "This browser supports Evolu in one tab only. Close this tab and use the already open tab.",
                     );
                   }
@@ -97,7 +96,7 @@ export const createEvoluDeps = (
     createDbWorker,
     createBroadcastChannel,
     createMessageChannel,
-    lockManager: globalThis.navigator.locks,
+    lockManager: navigator.locks,
     reloadApp,
     sharedWorker,
   });

package/src/local-first/Shared.worker.ts

@@ -21,7 +21,7 @@ import {
 const run = createRun({
   ...createWorkerDeps(),
   createWebSocket,
-  lockManager: globalThis.navigator.locks,
+  lockManager: navigator.locks,
 });
 
 void run(async (run) => {
@@ -37,7 +37,7 @@ void run(async (run) => {
     SharedWorkerOutput
   >(self);
 
-  await globalThis.navigator.locks.request(
+  await navigator.locks.request(
     "evolu-one-tab-sharedworker-polyfill",
     { ifAvailable: true, mode: "exclusive" },
     async (lock) => {