@evolu/web 3.2.0 → 3.4.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/Evolu.d.ts

@@ -1,27 +1,11 @@
 import { type ConsoleDep, type ReloadAppDep } from "@evolu/common";
-import type { EvoluDeps } from "@evolu/common/local-first";
+import type { EvoluDeps, RequestPersistentStorageDep } from "@evolu/common/local-first";
 export interface SharedWorkerUnsupported {
     readonly type: "SharedWorkerUnsupported";
 }
 export interface SharedWorkerUnsupportedDep {
     readonly onSharedWorkerUnsupported: () => void;
 }
-export interface StorageUnavailableDep {
-    /**
-     * Called when the browser offers no persistent storage, as in Safari's
-     * Private Browsing, so every database is kept in memory. See Storage in the
-     * Shared module of `@evolu/common`.
-     *
-     * The app keeps working. Data synced with a relay comes back, as on a new
-     * device, and nothing stays on the device once the tabs close. That suits
-     * someone checking their app on a borrowed phone, so a message such as
-     * "Nothing from this session is kept on this device." tells the user what to
-     * expect. Data that exists only locally, or has not synced yet, is lost when
-     * the tab hosting the database closes or navigates away, even while other
-     * tabs stay open.
-     */
-    readonly onStorageUnavailable: () => void;
-}
 /**
  * Creates Evolu dependencies for the web platform.
  *
@@ -42,14 +26,25 @@ export interface StorageUnavailableDep {
  * the user comes back to it.
  *
  * Where the browser offers no persistent storage, as in Safari's Private
- * Browsing, the database is kept in memory, and
- * {@link StorageUnavailableDep.onStorageUnavailable} lets the app tell the
- * user.
+ * Browsing or a Firefox private window, the database is kept in memory, and
+ * {@link Evolu.devicePersistence} resolves to `NotPersisted`, so the app can
+ * tell the user. Data that exists only locally, or has not synced yet, is lost
+ * when the tab hosting the database closes or navigates away, even while other
+ * tabs stay open.
+ *
+ * After the first local mutation of a database the browser stores, this tab
+ * asks the browser once with `navigator.storage.persist()` not to delete the
+ * site's data when disk space runs low. Chrome and Safari decide silently, and
+ * Firefox asks the user, so every tab asks until the user allows it. A custom
+ * {@link RequestPersistentStorageDep.requestPersistentStorage} replaces the
+ * request, for example with `constVoid` to never ask. See [Will my data stay on
+ * the
+ * device?](https://www.evolu.dev/docs/faq#will-my-data-stay-on-the-device).
  *
  * A custom {@link ReloadApp} replaces the default page reload, for example to
  * save state first. It should end by reloading the page, because the other
  * build waits until this tab reloads or closes, and a page restored from the
  * back-forward cache cannot work until it reloads.
  */
-export declare const createEvoluDeps: (deps?: Partial<ConsoleDep> & Partial<ReloadAppDep> & Partial<SharedWorkerUnsupportedDep> & Partial<StorageUnavailableDep>) => EvoluDeps;
+export declare const createEvoluDeps: (deps?: Partial<ConsoleDep> & Partial<ReloadAppDep> & Partial<SharedWorkerUnsupportedDep> & Partial<RequestPersistentStorageDep>) => EvoluDeps;
 //# sourceMappingURL=Evolu.d.ts.map

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,EAGL,KAAK,UAAU,EAEf,KAAK,YAAY,EAElB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAIV,SAAS,EAIV,MAAM,2BAA2B,CAAC;AAgBnC,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,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,oBAAoB,EAAE,MAAM,IAAI,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,UACpB,OAAO,CAAC,UAAU,CAAC,GACvB,OAAO,CAAC,YAAY,CAAC,GACrB,OAAO,CAAC,0BAA0B,CAAC,GACnC,OAAO,CAAC,qBAAqB,CAAC,KAC/B,SAiPF,CAAC"}
+{"version":3,"file":"Evolu.d.ts","sourceRoot":"","sources":["../../../src/local-first/Evolu.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAEf,KAAK,YAAY,EAElB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAKV,SAAS,EACT,2BAA2B,EAI5B,MAAM,2BAA2B,CAAC;AAgBnC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,eAAe,UACpB,OAAO,CAAC,UAAU,CAAC,GACvB,OAAO,CAAC,YAAY,CAAC,GACrB,OAAO,CAAC,0BAA0B,CAAC,GACnC,OAAO,CAAC,2BAA2B,CAAC,KACrC,SAsPF,CAAC"}

package/dist/src/local-first/Evolu.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 { exhaustiveCheck, trySync, } from "@evolu/common";
+import { exhaustiveCheck, tryAsync, trySync, } from "@evolu/common";
 import { BuildWaiting, BuildWaitingRequest, buildsBroadcastChannelName, createEvoluDeps as createCommonEvoluDeps, } from "@evolu/common/local-first";
 import { reloadApp } from "../Platform.js";
 import { createBroadcastChannel, createMessageChannel, createSharedWorker, createWorker, installOneTabSharedWorkerPolyfill, } from "../Worker.js";
@@ -74,9 +74,20 @@ import { createBroadcastChannel, createMessageChannel, createSharedWorker, creat
  * the user comes back to it.
  *
  * Where the browser offers no persistent storage, as in Safari's Private
- * Browsing, the database is kept in memory, and
- * {@link StorageUnavailableDep.onStorageUnavailable} lets the app tell the
- * user.
+ * Browsing or a Firefox private window, the database is kept in memory, and
+ * {@link Evolu.devicePersistence} resolves to `NotPersisted`, so the app can
+ * tell the user. Data that exists only locally, or has not synced yet, is lost
+ * when the tab hosting the database closes or navigates away, even while other
+ * tabs stay open.
+ *
+ * After the first local mutation of a database the browser stores, this tab
+ * asks the browser once with `navigator.storage.persist()` not to delete the
+ * site's data when disk space runs low. Chrome and Safari decide silently, and
+ * Firefox asks the user, so every tab asks until the user allows it. A custom
+ * {@link RequestPersistentStorageDep.requestPersistentStorage} replaces the
+ * request, for example with `constVoid` to never ask. See [Will my data stay on
+ * the
+ * device?](https://www.evolu.dev/docs/faq#will-my-data-stay-on-the-device).
  *
  * A custom {@link ReloadApp} replaces the default page reload, for example to
  * save state first. It should end by reloading the page, because the other
@@ -105,6 +116,7 @@ export const createEvoluDeps = (deps = {}) => {
         const earlyAnnouncedWorkerIds = new Set();
         // Checks whether the user left this tab while another build waits.
         let focusCheckId = null;
+        let isPersistentStorageRequested = false;
         const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
         const buildsBroadcastChannel = disposer.use(createBroadcastChannel(buildsBroadcastChannelName));
         const stopFocusCheck = () => {
@@ -206,11 +218,6 @@ export const createEvoluDeps = (deps = {}) => {
                     });
                     break;
                 }
-                case "StorageUnavailable": {
-                    deps.onStorageUnavailable?.();
-                    forward(message);
-                    break;
-                }
                 case "SharedWorkerUnsupported": {
                     if (deps.onSharedWorkerUnsupported) {
                         deps.onSharedWorkerUnsupported();
@@ -259,7 +266,18 @@ export const createEvoluDeps = (deps = {}) => {
                 },
             },
         };
+        const requestPersistentStorage = () => {
+            if (isPersistentStorageRequested)
+                return;
+            isPersistentStorageRequested = true;
+            void tryAsync(async () => {
+                if (await navigator.storage.persisted())
+                    return;
+                await navigator.storage.persist();
+            });
+        };
         const evoluDeps = disposer.use(createCommonEvoluDeps({
+            requestPersistentStorage,
             ...deps,
             createDbWorker,
             createBroadcastChannel,

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

@@ -53,15 +53,25 @@ 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,
-    // Safari's Private Browsing offers no OPFS; see Storage in the Shared module.
-    isPersistentStorageAvailable: async () => (await tryAsync(() => navigator.storage.getDirectory())).ok,
+    // Safari's Private Browsing and Firefox's private windows offer no OPFS, and
+    // a browser may delete it, as Chrome's incognito does when the session ends;
+    // see Storage in the Shared module.
+    getDevicePersistence: async () => (await tryAsync(() => navigator.storage.getDirectory())).ok
+        ? "Unknown"
+        : "NotPersisted",
     lockManager: navigator.locks,
 });
 void run(async (run) => {
@@ -70,7 +80,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.4.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.14.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.14.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

@@ -148,26 +148,59 @@ describe("createEvoluDeps", () => {
     });
   });
 
-  describe("storage unavailable", () => {
-    const workerId = createIdFromString<"SharedWorker">("worker");
+  describe("persistent storage request", () => {
+    const setupStorage = (isPersisted: boolean) => ({
+      persisted: mock.fn(() => Promise.resolve(isPersisted)),
+      persist: mock.fn(() => Promise.resolve(true)),
+    });
 
-    it("tells the app when its worker keeps databases in memory", () => {
-      const onStorageUnavailable = mock.fn<() => void>();
-      using setup = setupWebEvoluDeps({ onStorageUnavailable });
-      setup.connect(workerId);
+    it("asks the browser once to keep the site's data", async () => {
+      const storage = setupStorage(false);
+      using setup = setupWebEvoluDeps({ storage });
 
-      setup.post({ type: "StorageUnavailable" });
+      setup.deps.requestPersistentStorage?.();
+      setup.deps.requestPersistentStorage?.();
+      await waitForMacrotask();
 
-      assertSame(onStorageUnavailable.mock.callCount(), 1);
+      assertSame(storage.persisted.mock.callCount(), 1);
+      assertSame(storage.persist.mock.callCount(), 1);
     });
 
-    it("works without a callback", () => {
-      using setup = setupWebEvoluDeps();
-      setup.connect(workerId);
+    it("does not ask when the site's data is already persistent", async () => {
+      const storage = setupStorage(true);
+      using setup = setupWebEvoluDeps({ storage });
 
-      setup.post({ type: "StorageUnavailable" });
+      setup.deps.requestPersistentStorage?.();
+      await waitForMacrotask();
 
-      assertSame(setup.reloadApp.mock.callCount(), 0);
+      assertSame(storage.persist.mock.callCount(), 0);
+    });
+
+    it("ignores a browser that refuses to answer", async () => {
+      const storage = {
+        persisted: mock.fn(() =>
+          Promise.reject(new TypeError("Storage is disabled.")),
+        ),
+        persist: mock.fn(() => Promise.resolve(true)),
+      };
+      using setup = setupWebEvoluDeps({ storage });
+
+      setup.deps.requestPersistentStorage?.();
+      await waitForMacrotask();
+
+      assertSame(storage.persist.mock.callCount(), 0);
+    });
+
+    it("uses the app's request instead", async () => {
+      const storage = setupStorage(false);
+      const requestPersistentStorage = mock.fn<() => void>();
+      using setup = setupWebEvoluDeps({ storage, requestPersistentStorage });
+
+      setup.deps.requestPersistentStorage?.();
+      await waitForMacrotask();
+
+      assertSame(requestPersistentStorage.mock.callCount(), 1);
+      assertSame(storage.persisted.mock.callCount(), 0);
     });
   });
 
@@ -443,7 +476,8 @@ const setupWebEvoluDeps = ({
   isSessionStorageAvailable = true,
   refusalReloads,
   reloadedFor,
-  onStorageUnavailable,
+  storage,
+  requestPersistentStorage,
 }: {
   hasFocus?: boolean;
   isAutomaticReload?: boolean;
@@ -452,7 +486,9 @@ const setupWebEvoluDeps = ({
   refusalReloads?: string;
   /** The stored waiting workers, as a previous page load left them. */
   reloadedFor?: string;
-  onStorageUnavailable?: () => void;
+  /** Stands in for `navigator.storage`. */
+  storage?: Pick<StorageManager, "persist" | "persisted">;
+  requestPersistentStorage?: () => void;
 } = {}) => {
   using disposer = new DisposableStack();
   const sharedWorkerPort = createClosableNativePort<unknown>();
@@ -539,12 +575,17 @@ const setupWebEvoluDeps = ({
   );
   let hasFocus = initialHasFocus;
   disposer.use(testStubGlobal("document", { hasFocus: () => hasFocus }));
+  if (storage) {
+    disposer.use(
+      testStubGlobal("navigator", { locks: navigator.locks, storage }),
+    );
+  }
   const reloadApp = mock.fn<ReloadApp>();
 
   const deps = createEvoluDeps({
     console: createConsole({ level: "silent" }),
     reloadApp,
-    ...(onStorageUnavailable && { onStorageUnavailable }),
+    ...(requestPersistentStorage && { requestPersistentStorage }),
   });
   const builds = channels.find(
     (channel) => channel.name === buildsBroadcastChannelName,
@@ -572,6 +613,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/Evolu.ts

@@ -1,5 +1,6 @@
 import {
   exhaustiveCheck,
+  tryAsync,
   trySync,
   type ConsoleDep,
   type ReloadApp,
@@ -10,7 +11,9 @@ import type {
   SharedWorker as CommonSharedWorker,
   CreateDbWorker,
   DbWorkerInit,
+  Evolu,
   EvoluDeps,
+  RequestPersistentStorageDep,
   SharedWorkerId,
   SharedWorkerInput,
   SharedWorkerOutput,
@@ -38,23 +41,6 @@ export interface SharedWorkerUnsupportedDep {
   readonly onSharedWorkerUnsupported: () => void;
 }
 
-export interface StorageUnavailableDep {
-  /**
-   * Called when the browser offers no persistent storage, as in Safari's
-   * Private Browsing, so every database is kept in memory. See Storage in the
-   * Shared module of `@evolu/common`.
-   *
-   * The app keeps working. Data synced with a relay comes back, as on a new
-   * device, and nothing stays on the device once the tabs close. That suits
-   * someone checking their app on a borrowed phone, so a message such as
-   * "Nothing from this session is kept on this device." tells the user what to
-   * expect. Data that exists only locally, or has not synced yet, is lost when
-   * the tab hosting the database closes or navigates away, even while other
-   * tabs stay open.
-   */
-  readonly onStorageUnavailable: () => void;
-}
-
 /**
  * Creates Evolu dependencies for the web platform.
  *
@@ -75,9 +61,20 @@ export interface StorageUnavailableDep {
  * the user comes back to it.
  *
  * Where the browser offers no persistent storage, as in Safari's Private
- * Browsing, the database is kept in memory, and
- * {@link StorageUnavailableDep.onStorageUnavailable} lets the app tell the
- * user.
+ * Browsing or a Firefox private window, the database is kept in memory, and
+ * {@link Evolu.devicePersistence} resolves to `NotPersisted`, so the app can
+ * tell the user. Data that exists only locally, or has not synced yet, is lost
+ * when the tab hosting the database closes or navigates away, even while other
+ * tabs stay open.
+ *
+ * After the first local mutation of a database the browser stores, this tab
+ * asks the browser once with `navigator.storage.persist()` not to delete the
+ * site's data when disk space runs low. Chrome and Safari decide silently, and
+ * Firefox asks the user, so every tab asks until the user allows it. A custom
+ * {@link RequestPersistentStorageDep.requestPersistentStorage} replaces the
+ * request, for example with `constVoid` to never ask. See [Will my data stay on
+ * the
+ * device?](https://www.evolu.dev/docs/faq#will-my-data-stay-on-the-device).
  *
  * A custom {@link ReloadApp} replaces the default page reload, for example to
  * save state first. It should end by reloading the page, because the other
@@ -88,7 +85,7 @@ export const createEvoluDeps = (
   deps: Partial<ConsoleDep> &
     Partial<ReloadAppDep> &
     Partial<SharedWorkerUnsupportedDep> &
-    Partial<StorageUnavailableDep> = {},
+    Partial<RequestPersistentStorageDep> = {},
 ): EvoluDeps => {
   installOneTabSharedWorkerPolyfill();
   const reloadThisApp = deps.reloadApp ?? reloadApp;
@@ -110,6 +107,7 @@ export const createEvoluDeps = (
   const earlyAnnouncedWorkerIds = new Set<SharedWorkerId>();
   // Checks whether the user left this tab while another build waits.
   let focusCheckId: ReturnType<typeof setInterval> | null = null;
+  let isPersistentStorageRequested = false;
 
   using disposer = new DisposableStack();
   const buildsBroadcastChannel = disposer.use(
@@ -225,12 +223,6 @@ export const createEvoluDeps = (
         break;
       }
 
-      case "StorageUnavailable": {
-        deps.onStorageUnavailable?.();
-        forward(message);
-        break;
-      }
-
       case "SharedWorkerUnsupported": {
         if (deps.onSharedWorkerUnsupported) {
           deps.onSharedWorkerUnsupported();
@@ -292,8 +284,18 @@ export const createEvoluDeps = (
     },
   };
 
+  const requestPersistentStorage = (): void => {
+    if (isPersistentStorageRequested) return;
+    isPersistentStorageRequested = true;
+    void tryAsync(async () => {
+      if (await navigator.storage.persisted()) return;
+      await navigator.storage.persist();
+    });
+  };
+
   const evoluDeps = disposer.use(
     createCommonEvoluDeps({
+      requestPersistentStorage,
       ...deps,
       createDbWorker,
       createBroadcastChannel,

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

@@ -4,34 +4,62 @@ 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,
-  // Safari's Private Browsing offers no OPFS; see Storage in the Shared module.
-  isPersistentStorageAvailable: async () =>
-    (await tryAsync(() => navigator.storage.getDirectory())).ok,
+  // Safari's Private Browsing and Firefox's private windows offer no OPFS, and
+  // a browser may delete it, as Chrome's incognito does when the session ends;
+  // see Storage in the Shared module.
+  getDevicePersistence: async () =>
+    (await tryAsync(() => navigator.storage.getDirectory())).ok
+      ? "Unknown"
+      : "NotPersisted",
   lockManager: navigator.locks,
 });
 
 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);
   }