@evolu/web 3.2.0 → 3.3.0

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

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

package/dist/src/Sqlite.js

@@ -179,17 +179,24 @@ export const createWasmSqliteDriver = (name, options) => async (run) => {
             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({}));
+                    try {
+                        if (query.parameters.length > 0)
+                            prepared.bind(query.parameters);
+                        const rows = [];
+                        while (prepared.step()) {
+                            rows.push(prepared.get({}));
+                        }
+                        return {
+                            rows: rows,
+                            changes: db.changes(),
+                        };
+                    }
+                    finally {
+                        // SQLite refuses to bind a statement whose step failed until it is
+                        // reset. That reset returns the step's error again, which
+                        // PreparedStatement.reset would throw over the original one.
+                        sqlite3.capi.sqlite3_reset(prepared);
                     }
-                    prepared.reset();
-                    return {
-                        rows: rows,
-                        changes: db.changes(),
-                    };
                 }
                 const rows = db.exec(query.sql, {
                     returnValue: "resultRows",

package/dist/src/Worker.d.ts

@@ -44,7 +44,9 @@ export declare const createWorkerSelf: <Input, Output = never>(nativeSelf: Dedic
  * Creates an Evolu {@link SharedWorkerSelf} from a Web `SharedWorkerGlobalScope`
  * (`self` inside a shared worker).
  *
- * Disposing closes the shared worker scope for all connected clients.
+ * Disposing closes the shared worker scope for all connected clients. Browsers
+ * never pass a shared worker's uncaught errors to its pages; see
+ * {@link addUncaughtErrorListener}.
  */
 export declare const createSharedWorkerSelf: <Input, Output = never>(nativeSelf: SharedWorkerGlobalScope) => SharedWorkerSelf<Input, Output>;
 /**
@@ -55,6 +57,41 @@ export declare const createSharedWorkerSelf: <Input, Output = never>(nativeSelf:
  * `onMessage` is set, and does not share state across tabs.
  */
 export declare const createOneTabSharedWorkerSelfPolyfill: <Input, Output = never>(nativeSelf: DedicatedWorkerGlobalScope) => SharedWorkerSelf<Input, Output>;
+/**
+ * Passes each uncaught error and unhandled rejection of a worker global scope
+ * to `listener` as an `Error` from {@link defectToError}.
+ *
+ * Browsers never pass a shared worker's uncaught errors to a page's error
+ * handlers, and no worker passes its unhandled rejections to its page. A shared
+ * worker calls this with its global scope, `self`, to send them to its pages,
+ * for example over a BroadcastChannel. Defects of a Run from {@link createRun}
+ * arrive too, because it reports them with `reportError`, which dispatches
+ * "error" on the global scope.
+ *
+ * The events stay uncanceled, so the browser still logs them, and a dedicated
+ * worker still passes its uncaught errors to its page. The listeners stay until
+ * disposal, so they also receive errors after a Run's panic.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual } from "@evolu/common";
+ * import { addUncaughtErrorListener } from "@evolu/web";
+ *
+ * const messages: Array<string> = [];
+ * // A worker passes its global scope, `self`.
+ * const scope = new EventTarget();
+ * using _listener = addUncaughtErrorListener(scope, (error) => {
+ *   messages.push(error.message);
+ * });
+ *
+ * scope.dispatchEvent(
+ *   Object.assign(new Event("error"), { error: new Error("unexpected") }),
+ * );
+ * assertEqual(messages, ["unexpected"]);
+ * ```
+ */
+export declare const addUncaughtErrorListener: (scope: EventTarget, listener: (error: Error) => void) => Disposable;
 /** 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,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"}
+{"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;AAUvB,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;;;;;;;GAOG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,wBAAwB,UAC5B,WAAW,YACR,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAC/B,UAsBF,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,gBAAgB,QAAO,UAAU,GAC5C,yBAAyB,GACzB,uBAWD,CAAC"}

package/dist/src/Worker.js

@@ -50,7 +50,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { assertNonNullable, createConsole, createConsoleStoreOutput, disposable, } from "@evolu/common";
+import { assertNonNullable, createConsole, createConsoleStoreOutput, defectToError, disposable, } from "@evolu/common";
 /** Creates a {@link Worker} from a Web Worker. */
 export const createWorker = (nativeWorker) => wrap(nativeWorker);
 /**
@@ -176,7 +176,9 @@ 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.
+ * Disposing closes the shared worker scope for all connected clients. Browsers
+ * never pass a shared worker's uncaught errors to its pages; see
+ * {@link addUncaughtErrorListener}.
  */
 export const createSharedWorkerSelf = (nativeSelf) => {
     const self = {
@@ -285,6 +287,63 @@ export const createOneTabSharedWorkerSelfPolyfill = (nativeSelf) => {
         __disposeResources(env_3);
     }
 };
+/**
+ * Passes each uncaught error and unhandled rejection of a worker global scope
+ * to `listener` as an `Error` from {@link defectToError}.
+ *
+ * Browsers never pass a shared worker's uncaught errors to a page's error
+ * handlers, and no worker passes its unhandled rejections to its page. A shared
+ * worker calls this with its global scope, `self`, to send them to its pages,
+ * for example over a BroadcastChannel. Defects of a Run from {@link createRun}
+ * arrive too, because it reports them with `reportError`, which dispatches
+ * "error" on the global scope.
+ *
+ * The events stay uncanceled, so the browser still logs them, and a dedicated
+ * worker still passes its uncaught errors to its page. The listeners stay until
+ * disposal, so they also receive errors after a Run's panic.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual } from "@evolu/common";
+ * import { addUncaughtErrorListener } from "@evolu/web";
+ *
+ * const messages: Array<string> = [];
+ * // A worker passes its global scope, `self`.
+ * const scope = new EventTarget();
+ * using _listener = addUncaughtErrorListener(scope, (error) => {
+ *   messages.push(error.message);
+ * });
+ *
+ * scope.dispatchEvent(
+ *   Object.assign(new Event("error"), { error: new Error("unexpected") }),
+ * );
+ * assertEqual(messages, ["unexpected"]);
+ * ```
+ */
+export const addUncaughtErrorListener = (scope, listener) => {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_4, new DisposableStack(), false);
+        const { signal } = disposer.adopt(new AbortController(), (controller) => {
+            controller.abort();
+        });
+        scope.addEventListener("error", (event) => {
+            listener(defectToError(event.error));
+        }, { signal });
+        scope.addEventListener("unhandledrejection", (event) => {
+            listener(defectToError(event.reason));
+        }, { signal });
+        return disposable({}, disposer);
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        __disposeResources(env_4);
+    }
+};
 /** Creates deps shared by web worker entry points. */
 export const createWorkerDeps = () => {
     const consoleStoreOutput = createConsoleStoreOutput();

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

@@ -53,10 +53,16 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 /// <reference lib="webworker" />
 import { installPolyfills } from "@evolu/common/polyfills";
 installPolyfills();
-import { createWebSocket, ok, tryAsync, waitForAbort } from "@evolu/common";
-import { initSharedWorker } from "@evolu/common/local-first";
+import { createUnknownError, createWebSocket, ok, tryAsync, waitForAbort, } from "@evolu/common";
+import { consoleEntryOrErrorBroadcastChannelName, initSharedWorker, } from "@evolu/common/local-first";
 import { createRun } from "../Task.js";
-import { createOneTabSharedWorkerSelfPolyfill, createSharedWorkerSelf, createWorkerDeps, } from "../Worker.js";
+import { addUncaughtErrorListener, createBroadcastChannel, createOneTabSharedWorkerSelfPolyfill, createSharedWorkerSelf, createWorkerDeps, } from "../Worker.js";
+const errors = createBroadcastChannel(consoleEntryOrErrorBroadcastChannelName);
+// Each tab logs an uncaught error, including a Run defect, and sets it as its
+// evoluError.
+addUncaughtErrorListener(self, (error) => {
+    errors.postMessage({ type: "Error", error: createUnknownError(error) });
+});
 const run = createRun({
     ...createWorkerDeps(),
     createWebSocket,
@@ -70,7 +76,9 @@ void run(async (run) => {
         if ("onconnect" in self) {
             const env_2 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_2, await run.ok(initSharedWorker(createSharedWorkerSelf(self))), true);
+                // A panic closes the worker, so tabs that connect later start another.
+                const workerSelf = __addDisposableResource(env_2, createSharedWorkerSelf(self), false);
+                const _ = __addDisposableResource(env_2, await run.ok(initSharedWorker(workerSelf)), true);
                 return await run(waitForAbort);
             }
             catch (e_1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/web",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Evolu for web",
   "keywords": [
     "evolu",
@@ -35,7 +35,7 @@
     "@evolu/sqlite-wasm": "2.2.4"
   },
   "devDependencies": {
-    "@evolu/common": "8.11.0",
+    "@evolu/common": "8.13.0",
     "@evolu/typescript-config": "0.1.1",
     "@types/node": "^24.10.9",
     "@types/sharedworker": "^0.0.229",
@@ -44,7 +44,7 @@
     "user-agent-data-types": "^0.4.2"
   },
   "peerDependencies": {
-    "@evolu/common": "^8.11.0"
+    "@evolu/common": "^8.13.0"
   },
   "publishConfig": {
     "access": "public"

package/src/Sqlite.test.ts

@@ -117,10 +117,6 @@ const sqliteMock = (() => {
       return { data: "prepared" };
     }
 
-    reset(): void {
-      this.resetCount += 1;
-    }
-
     finalize(): void {
       this.finalized = true;
     }
@@ -193,6 +189,10 @@ const sqliteMock = (() => {
   const sqlite3 = {
     capi: {
       sqlite3_js_db_export: mock.fn(() => new Uint8Array([1, 2, 3])),
+      sqlite3_reset: mock.fn((statement: PreparedStatement) => {
+        statement.resetCount += 1;
+        return 0;
+      }),
       sqlite3mc_vfs_create: mock.fn(),
     },
     installOpfsSAHPoolVfs: mock.fn(() => Promise.resolve(pool)),
@@ -217,6 +217,7 @@ const sqliteMock = (() => {
       pool.unpauseVfs.mock.resetCalls();
       pool.unlink.mock.resetCalls();
       sqlite3.capi.sqlite3_js_db_export.mock.resetCalls();
+      sqlite3.capi.sqlite3_reset.mock.resetCalls();
       sqlite3.capi.sqlite3mc_vfs_create.mock.resetCalls();
       sqlite3.installOpfsSAHPoolVfs.mock.resetCalls();
     },

package/src/Sqlite.ts

@@ -178,18 +178,24 @@ export const createWasmSqliteDriver: CreateSqliteDriver =
         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({}));
+          try {
+            if (query.parameters.length > 0) prepared.bind(query.parameters);
+
+            const rows = [];
+            while (prepared.step()) {
+              rows.push(prepared.get({}));
+            }
+
+            return {
+              rows: rows as ReadonlyArray<SqliteRow>,
+              changes: db.changes(),
+            };
+          } finally {
+            // SQLite refuses to bind a statement whose step failed until it is
+            // reset. That reset returns the step's error again, which
+            // PreparedStatement.reset would throw over the original one.
+            sqlite3.capi.sqlite3_reset(prepared);
           }
-          prepared.reset();
-
-          return {
-            rows: rows as ReadonlyArray<SqliteRow>,
-            changes: db.changes(),
-          };
         }
 
         const rows = db.exec(query.sql, {

package/src/Worker.test.ts

@@ -1,5 +1,7 @@
 import {
   assertEqual,
+  assertFalse,
+  assertLength,
   assertNonNullable,
   assertSame,
   assertThrowsInstanceOf,
@@ -9,6 +11,7 @@ import {
 } from "@evolu/common";
 import { describe, it, mock, test } from "node:test";
 import {
+  addUncaughtErrorListener,
   createBroadcastChannel,
   createOneTabSharedWorkerSelfPolyfill,
   createMessageChannel,
@@ -450,6 +453,62 @@ test("createSharedWorkerSelf asserts when a connection arrives before onConnect
   );
 });
 
+describe("addUncaughtErrorListener", () => {
+  const dispatch = (
+    scope: EventTarget,
+    type: "error" | "unhandledrejection",
+    fields: object,
+  ): Event => {
+    const event = Object.assign(new Event(type, { cancelable: true }), fields);
+    scope.dispatchEvent(event);
+    return event;
+  };
+
+  it("passes uncaught errors and unhandled rejections without canceling them", () => {
+    const scope = new EventTarget();
+    const listener = mock.fn<(error: Error) => void>();
+    using _listener = addUncaughtErrorListener(scope, listener);
+    const error = new Error("uncaught");
+    const reason = new Error("rejected");
+
+    const errorEvent = dispatch(scope, "error", { error });
+    const rejectionEvent = dispatch(scope, "unhandledrejection", { reason });
+
+    const errors = listener.mock.calls.map((call) => call.arguments[0]);
+    assertLength(errors, 2);
+    assertSame(errors[0], error);
+    assertSame(errors[1], reason);
+    assertFalse(errorEvent.defaultPrevented);
+    assertFalse(rejectionEvent.defaultPrevented);
+  });
+
+  it("passes a thrown non-Error as an Error", () => {
+    const scope = new EventTarget();
+    const listener = mock.fn<(error: Error) => void>();
+    using _listener = addUncaughtErrorListener(scope, listener);
+
+    dispatch(scope, "error", { error: null });
+    dispatch(scope, "unhandledrejection", { reason: "rejected" });
+
+    assertEqual(
+      listener.mock.calls.map((call) => call.arguments[0].message),
+      ["Defect: null", 'Defect: "rejected"'],
+    );
+  });
+
+  it("stops passing errors after disposal", () => {
+    const scope = new EventTarget();
+    const listener = mock.fn<(error: Error) => void>();
+    const uncaughtErrorListener = addUncaughtErrorListener(scope, listener);
+
+    uncaughtErrorListener[Symbol.dispose]();
+    dispatch(scope, "error", { error: new Error("uncaught") });
+    dispatch(scope, "unhandledrejection", { reason: new Error("rejected") });
+
+    assertSame(listener.mock.callCount(), 0);
+  });
+});
+
 test("createWorkerDeps stores console output entries and exposes createMessagePort", () => {
   const deps = createWorkerDeps();
 

package/src/Worker.ts

@@ -18,8 +18,10 @@ import {
   assertNonNullable,
   createConsole,
   createConsoleStoreOutput,
+  defectToError,
   disposable,
 } from "@evolu/common";
+import type { createRun } from "./Task.ts";
 
 /** Creates a {@link Worker} from a Web Worker. */
 export const createWorker = <Input, Output>(
@@ -159,7 +161,9 @@ export const createWorkerSelf = <Input, Output = never>(
  * Creates an Evolu {@link SharedWorkerSelf} from a Web `SharedWorkerGlobalScope`
  * (`self` inside a shared worker).
  *
- * Disposing closes the shared worker scope for all connected clients.
+ * Disposing closes the shared worker scope for all connected clients. Browsers
+ * never pass a shared worker's uncaught errors to its pages; see
+ * {@link addUncaughtErrorListener}.
  */
 export const createSharedWorkerSelf = <Input, Output = never>(
   nativeSelf: SharedWorkerGlobalScope,
@@ -271,6 +275,67 @@ export const createOneTabSharedWorkerSelfPolyfill = <Input, Output = never>(
   };
 };
 
+/**
+ * Passes each uncaught error and unhandled rejection of a worker global scope
+ * to `listener` as an `Error` from {@link defectToError}.
+ *
+ * Browsers never pass a shared worker's uncaught errors to a page's error
+ * handlers, and no worker passes its unhandled rejections to its page. A shared
+ * worker calls this with its global scope, `self`, to send them to its pages,
+ * for example over a BroadcastChannel. Defects of a Run from {@link createRun}
+ * arrive too, because it reports them with `reportError`, which dispatches
+ * "error" on the global scope.
+ *
+ * The events stay uncanceled, so the browser still logs them, and a dedicated
+ * worker still passes its uncaught errors to its page. The listeners stay until
+ * disposal, so they also receive errors after a Run's panic.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual } from "@evolu/common";
+ * import { addUncaughtErrorListener } from "@evolu/web";
+ *
+ * const messages: Array<string> = [];
+ * // A worker passes its global scope, `self`.
+ * const scope = new EventTarget();
+ * using _listener = addUncaughtErrorListener(scope, (error) => {
+ *   messages.push(error.message);
+ * });
+ *
+ * scope.dispatchEvent(
+ *   Object.assign(new Event("error"), { error: new Error("unexpected") }),
+ * );
+ * assertEqual(messages, ["unexpected"]);
+ * ```
+ */
+export const addUncaughtErrorListener = (
+  scope: EventTarget,
+  listener: (error: Error) => void,
+): Disposable => {
+  using disposer = new DisposableStack();
+  const { signal } = disposer.adopt(new AbortController(), (controller) => {
+    controller.abort();
+  });
+
+  scope.addEventListener(
+    "error",
+    (event) => {
+      listener(defectToError((event as ErrorEvent).error));
+    },
+    { signal },
+  );
+  scope.addEventListener(
+    "unhandledrejection",
+    (event) => {
+      listener(defectToError((event as PromiseRejectionEvent).reason));
+    },
+    { signal },
+  );
+
+  return disposable({}, disposer);
+};
+
 /** Creates deps shared by web worker entry points. */
 export const createWorkerDeps = (): WorkerDeps &
   CreateBroadcastChannelDep &

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

@@ -572,6 +572,7 @@ const setupWebEvoluDeps = ({
         sqliteSchema: { tables: {}, indexes: [] },
         encryptionKey: testAppOwner.encryptionKey,
         memoryOnly: false,
+        sharedWorkerId: createIdFromString<"SharedWorker">("worker"),
         port: createClosableNativePort() as unknown as NativeMessagePort<
           DbWorkerOutput,
           DbWorkerInput

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

@@ -4,20 +4,41 @@ declare const self: DedicatedWorkerGlobalScope | SharedWorkerGlobalScope;
 import { installPolyfills } from "@evolu/common/polyfills";
 installPolyfills();
 
-import { createWebSocket, ok, tryAsync, waitForAbort } from "@evolu/common";
+import {
+  createUnknownError,
+  createWebSocket,
+  ok,
+  tryAsync,
+  waitForAbort,
+} from "@evolu/common";
 import type {
+  ConsoleEntryOrError,
   SharedWorkerInput,
   SharedWorkerOutput,
 } from "@evolu/common/local-first";
-import { initSharedWorker } from "@evolu/common/local-first";
+import {
+  consoleEntryOrErrorBroadcastChannelName,
+  initSharedWorker,
+} from "@evolu/common/local-first";
 import type { SharedWorkerUnsupported } from "./Evolu.ts";
 import { createRun } from "../Task.ts";
 import {
+  addUncaughtErrorListener,
+  createBroadcastChannel,
   createOneTabSharedWorkerSelfPolyfill,
   createSharedWorkerSelf,
   createWorkerDeps,
 } from "../Worker.ts";
 
+const errors = createBroadcastChannel<ConsoleEntryOrError>(
+  consoleEntryOrErrorBroadcastChannelName,
+);
+// Each tab logs an uncaught error, including a Run defect, and sets it as its
+// evoluError.
+addUncaughtErrorListener(self, (error) => {
+  errors.postMessage({ type: "Error", error: createUnknownError(error) });
+});
+
 const run = createRun({
   ...createWorkerDeps(),
   createWebSocket,
@@ -29,9 +50,12 @@ const run = createRun({
 
 void run(async (run) => {
   if ("onconnect" in self) {
-    await using _ = await run.ok(
-      initSharedWorker(createSharedWorkerSelf(self)),
-    );
+    // A panic closes the worker, so tabs that connect later start another.
+    using workerSelf = createSharedWorkerSelf<
+      SharedWorkerInput,
+      SharedWorkerOutput
+    >(self);
+    await using _ = await run.ok(initSharedWorker(workerSelf));
     return await run(waitForAbort);
   }