@evolu/web 3.0.2 → 3.1.1

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

@@ -15,7 +15,7 @@ import type {
   WorkerSelf,
 } from "@evolu/common";
 import {
-  assert,
+  assertNonNullable,
   createConsole,
   createConsoleStoreOutput,
   disposable,
@@ -117,6 +117,7 @@ export const createBroadcastChannel: CreateBroadcastChannel = <
 
   disposer.defer(() => {
     disposed = true;
+    // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
     nativeBroadcastChannel.onmessage = null;
     nativeBroadcastChannel.close();
   });
@@ -134,6 +135,7 @@ export const createBroadcastChannel: CreateBroadcastChannel = <
       set onMessage(fn) {
         if (disposed) return;
         onMessageHandler = fn;
+        // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
         nativeBroadcastChannel.onmessage = fn
           ? (event: MessageEvent<Output>) => {
               fn(event.data);
@@ -150,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);
 
 /**
@@ -160,19 +162,21 @@ 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,
     [Symbol.dispose]: () => {
+      // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
       nativeSelf.onconnect = null;
       nativeSelf.close();
     },
   };
 
+  // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
   nativeSelf.onconnect = (e) => {
-    assert(
-      self.onConnect != null,
+    assertNonNullable(
+      self.onConnect,
       "onConnect must be set before receiving connections",
     );
     self.onConnect(wrap<Output, Input>(e.ports[0]));
@@ -189,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();
 
@@ -203,12 +207,14 @@ export const createOneTabSharedWorkerSelfPolyfill = <Input, Output = never>(
     messages.length = 0;
     onConnectHandler = null;
     onMessageHandler = null;
+    // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
     nativeSelf.onmessage = null;
     nativeSelf.close();
   });
 
   const disposables = disposer.move();
 
+  // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
   nativeSelf.onmessage = (event: MessageEvent<Input>) => {
     if (disposables.disposed) return;
 
@@ -300,10 +306,12 @@ const wrap = <Input, Output>(
       onMessageHandler = fn;
       if (fn) {
         // Messages are queued until onMessage is assigned.
+        // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
         native.onmessage = (event: MessageEvent<Output>) => {
           fn(event.data);
         };
       } else {
+        // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
         native.onmessage = null;
       }
     },
@@ -311,6 +319,7 @@ const wrap = <Input, Output>(
     native: native as unknown as NativeMessagePort<Input, Output>,
 
     [Symbol.dispose]: () => {
+      // oxlint-disable-next-line unicorn/prefer-add-event-listener -- This adapter owns and clears one handler.
       native.onmessage = null;
       if ("terminate" in native) native.terminate();
       else native.close();

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from "./local-first/index.ts";
-export { availableParallelism } from "./Platform.ts";
+export { availableParallelism, isApplePlatform } from "./Platform.ts";
 export * from "./Sqlite.ts";
 export * from "./Task.ts";
 export * from "./Worker.ts";

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/LocalAuth.ts

@@ -226,9 +226,12 @@ const createCredentialCreationOptions =
         displayName: username,
       },
       pubKeyCredParams: [
-        { type: "public-key", alg: -8 }, // Ed25519
-        { type: "public-key", alg: -7 }, // ES256
-        { type: "public-key", alg: -257 }, // RS256
+        // Ed25519
+        { type: "public-key", alg: -8 },
+        // ES256
+        { type: "public-key", alg: -7 },
+        // RS256
+        { type: "public-key", alg: -257 },
       ],
       attestation: "none",
       authenticatorSelection: {