@evolu/web 3.4.0 → 3.4.1

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,kBAyLlC,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,kBA4LlC,CAAC"}

package/dist/src/Sqlite.js

@@ -81,9 +81,11 @@ export const createWasmSqliteDriver = (name, options) => async (run) => {
             // DbWorker that ended without closing it, because its tab closed,
             // crashed or navigated away, can hold pool files after the lock has
             // passed on: WebKit releases a terminated worker's locks and its files
-            // separately, in no set order. sqlite-wasm cannot set up a pool with a
-            // held file, and it then deletes the pool directory, which the held file
-            // usually but not always prevents. Only a worker that has ended can hold
+            // separately, in no set order
+            // (https://bugs.webkit.org/show_bug.cgi?id=301520). sqlite-wasm cannot
+            // set up a pool with a held file, and it then deletes the pool
+            // directory, which the held file usually but not always prevents. Only
+            // a worker that has ended can hold
             // the files, and it can only release them, so the pool is set up once
             // every file opens.
             const canOpenPoolFiles = async () => {
@@ -101,7 +103,8 @@ export const createWasmSqliteDriver = (name, options) => async (run) => {
                     const accessHandle = await tryAsync(() => handle.createSyncAccessHandle());
                     if (!accessHandle.ok) {
                         // WebKit rejects a held file with InvalidStateError, other
-                        // engines with NoModificationAllowedError, as the spec says.
+                        // engines with NoModificationAllowedError, as the spec says
+                        // (https://bugs.webkit.org/show_bug.cgi?id=326135).
                         // WebKit also uses InvalidStateError for a closed or invalid
                         // handle and a stopped context. A retry opens fresh handles from
                         // a new listing, and a stopped context ends the loop with its

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

@@ -22,8 +22,9 @@ export interface SharedWorkerUnsupportedDep {
  *
  * When the page enters the browser's back-forward cache, as Safari does on
  * every navigation away, this tab ends its part as if it closed: it stops the
- * database workers it hosts, so another tab takes them over, and it reloads if
- * the user comes back to it.
+ * database workers it hosts, so another tab takes them over, the shared worker
+ * ends this tab's Evolu instances, and the tab reloads if the user comes back
+ * to it.
  *
  * Where the browser offers no persistent storage, as in Safari's Private
  * Browsing or a Firefox private window, the database is kept in memory, and

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,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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;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,SAgSF,CAAC"}

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

@@ -70,8 +70,9 @@ import { createBroadcastChannel, createMessageChannel, createSharedWorker, creat
  *
  * When the page enters the browser's back-forward cache, as Safari does on
  * every navigation away, this tab ends its part as if it closed: it stops the
- * database workers it hosts, so another tab takes them over, and it reloads if
- * the user comes back to it.
+ * database workers it hosts, so another tab takes them over, the shared worker
+ * ends this tab's Evolu instances, and the tab reloads if the user comes back
+ * to it.
  *
  * Where the browser offers no persistent storage, as in Safari's Private
  * Browsing or a Firefox private window, the database is kept in memory, and
@@ -276,21 +277,45 @@ export const createEvoluDeps = (deps = {}) => {
                 await navigator.storage.persist();
             });
         };
+        // Disposing the deps releases the locks this page holds through them, as
+        // closing the page would, and a lock granted afterwards is released at once.
+        // The SharedWorker learns that an Evolu instance ended when it gets the lock
+        // the instance holds. Chrome keeps the locks of a page in its back-forward
+        // cache, and a request made before the page entered the cache waits until
+        // Chrome drops the page (https://issues.chromium.org/issues/567630881), so
+        // the SharedWorker would keep syncing the owners of a cached tab's instances
+        // and rerunning their queries.
+        let areLocksReleased = false;
+        const locksReleased = Promise.withResolvers();
+        disposer.defer(() => {
+            areLocksReleased = true;
+            locksReleased.resolve();
+        });
+        function requestLock(name, ...args) {
+            const [options, callback] = args.length === 1 ? [{}, args[0]] : args;
+            return navigator.locks.request(name, options, (lock) => areLocksReleased
+                ? undefined
+                : Promise.race([callback(lock), locksReleased.promise]));
+        }
         const evoluDeps = disposer.use(createCommonEvoluDeps({
             requestPersistentStorage,
             ...deps,
             createDbWorker,
             createBroadcastChannel,
             createMessageChannel,
-            lockManager: navigator.locks,
+            lockManager: {
+                query: () => navigator.locks.query(),
+                request: requestLock,
+            },
             reloadApp: reloadThisApp,
             sharedWorker,
         }));
-        // A page entering the back-forward cache is frozen with its DbWorkers, which
-        // keep their database locks, so the other tabs would stall. WebKit also
-        // releases the page's own locks, so a restored page would work with state
-        // the other tabs gave up on. The page therefore ends its part as if it
-        // closed, and reloads when it is shown again.
+        // A page entering the back-forward cache is frozen with its DbWorkers, and
+        // WebKit keeps their database locks while the page is cached
+        // (https://bugs.webkit.org/show_bug.cgi?id=316904), so the other tabs would
+        // stall. WebKit also releases the page's own locks, so a restored page would
+        // work with state the other tabs gave up on. The page therefore ends its part
+        // as if it closed, and reloads when it is shown again.
         const reloadRestoredPage = (event) => {
             if (event.persisted)
                 reloadThisApp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/web",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "Evolu for web",
   "keywords": [
     "evolu",
@@ -35,7 +35,7 @@
     "@evolu/sqlite-wasm": "2.2.4"
   },
   "devDependencies": {
-    "@evolu/common": "8.14.0",
+    "@evolu/common": "8.18.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.14.0"
+    "@evolu/common": "^8.18.0"
   },
   "publishConfig": {
     "access": "public"

package/src/Sqlite.ts

@@ -53,9 +53,11 @@ export const createWasmSqliteDriver: CreateSqliteDriver =
       // DbWorker that ended without closing it, because its tab closed,
       // crashed or navigated away, can hold pool files after the lock has
       // passed on: WebKit releases a terminated worker's locks and its files
-      // separately, in no set order. sqlite-wasm cannot set up a pool with a
-      // held file, and it then deletes the pool directory, which the held file
-      // usually but not always prevents. Only a worker that has ended can hold
+      // separately, in no set order
+      // (https://bugs.webkit.org/show_bug.cgi?id=301520). sqlite-wasm cannot
+      // set up a pool with a held file, and it then deletes the pool
+      // directory, which the held file usually but not always prevents. Only
+      // a worker that has ended can hold
       // the files, and it can only release them, so the pool is set up once
       // every file opens.
       const canOpenPoolFiles = async (): Promise<boolean> => {
@@ -76,7 +78,8 @@ export const createWasmSqliteDriver: CreateSqliteDriver =
           );
           if (!accessHandle.ok) {
             // WebKit rejects a held file with InvalidStateError, other
-            // engines with NoModificationAllowedError, as the spec says.
+            // engines with NoModificationAllowedError, as the spec says
+            // (https://bugs.webkit.org/show_bug.cgi?id=326135).
             // WebKit also uses InvalidStateError for a closed or invalid
             // handle and a stopped context. A retry opens fresh handles from
             // a new listing, and a stopped context ends the loop with its

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

@@ -1,4 +1,5 @@
 import {
+  acquireLeaderLock,
   assertEqual,
   assertFalse,
   assertNonNullable,
@@ -7,6 +8,7 @@ import {
   createConsole,
   createIdFromString,
   PositiveInt,
+  testCreateRun,
   testName,
   testStubGlobal,
   type NativeMessagePort,
@@ -222,6 +224,39 @@ describe("createEvoluDeps", () => {
       assertSame(setup.reloadApp.mock.callCount(), 0);
     });
 
+    it("releases the locks of its Evolu instances when the page enters the cache", async () => {
+      using setup = setupWebEvoluDeps();
+      await using run = testCreateRun({
+        lockManager: setup.deps.lockManager,
+      });
+      await using _instanceLock = await run.ok(
+        acquireLeaderLock("cached-instance"),
+      );
+      assertFalse(await isLockAvailable("evolu-leaderlock-cached-instance"));
+
+      setup.dispatchPageTransition("pagehide", true);
+      await waitForMacrotask();
+
+      assertTrue(await isLockAvailable("evolu-leaderlock-cached-instance"));
+    });
+
+    it("releases at once a lock granted after the page entered the cache", async () => {
+      using setup = setupWebEvoluDeps();
+      const name = "evolu-granted-after-cache";
+      const held = Promise.withResolvers<void>();
+      const holding = navigator.locks.request(name, () => held.promise);
+      const callback = mock.fn<LockGrantedCallback<void>>();
+      const request = setup.deps.lockManager.request(name, callback);
+
+      setup.dispatchPageTransition("pagehide", true);
+      held.resolve();
+      await holding;
+      await request;
+
+      assertSame(callback.mock.callCount(), 0);
+      assertTrue(await isLockAvailable(name));
+    });
+
     it("reloads once when the page is restored from the cache", () => {
       using setup = setupWebEvoluDeps();
       setup.dispatchPageTransition("pageshow", false);

package/src/local-first/Evolu.ts

@@ -57,8 +57,9 @@ export interface SharedWorkerUnsupportedDep {
  *
  * When the page enters the browser's back-forward cache, as Safari does on
  * every navigation away, this tab ends its part as if it closed: it stops the
- * database workers it hosts, so another tab takes them over, and it reloads if
- * the user comes back to it.
+ * database workers it hosts, so another tab takes them over, the shared worker
+ * ends this tab's Evolu instances, and the tab reloads if the user comes back
+ * to it.
  *
  * Where the browser offers no persistent storage, as in Safari's Private
  * Browsing or a Firefox private window, the database is kept in memory, and
@@ -293,6 +294,44 @@ export const createEvoluDeps = (
     });
   };
 
+  // Disposing the deps releases the locks this page holds through them, as
+  // closing the page would, and a lock granted afterwards is released at once.
+  // The SharedWorker learns that an Evolu instance ended when it gets the lock
+  // the instance holds. Chrome keeps the locks of a page in its back-forward
+  // cache, and a request made before the page entered the cache waits until
+  // Chrome drops the page (https://issues.chromium.org/issues/567630881), so
+  // the SharedWorker would keep syncing the owners of a cached tab's instances
+  // and rerunning their queries.
+  let areLocksReleased = false;
+  const locksReleased = Promise.withResolvers<void>();
+  disposer.defer(() => {
+    areLocksReleased = true;
+    locksReleased.resolve();
+  });
+
+  function requestLock<T>(
+    name: string,
+    callback: LockGrantedCallback<T>,
+  ): Promise<Awaited<T>>;
+  function requestLock<T>(
+    name: string,
+    options: LockOptions,
+    callback: LockGrantedCallback<T>,
+  ): Promise<Awaited<T>>;
+  function requestLock(
+    name: string,
+    ...args:
+      | [LockGrantedCallback<unknown>]
+      | [LockOptions, LockGrantedCallback<unknown>]
+  ): Promise<unknown> {
+    const [options, callback] = args.length === 1 ? [{}, args[0]] : args;
+    return navigator.locks.request(name, options, (lock) =>
+      areLocksReleased
+        ? undefined
+        : Promise.race([callback(lock), locksReleased.promise]),
+    );
+  }
+
   const evoluDeps = disposer.use(
     createCommonEvoluDeps({
       requestPersistentStorage,
@@ -300,17 +339,21 @@ export const createEvoluDeps = (
       createDbWorker,
       createBroadcastChannel,
       createMessageChannel,
-      lockManager: navigator.locks,
+      lockManager: {
+        query: () => navigator.locks.query(),
+        request: requestLock,
+      },
       reloadApp: reloadThisApp,
       sharedWorker,
     }),
   );
 
-  // A page entering the back-forward cache is frozen with its DbWorkers, which
-  // keep their database locks, so the other tabs would stall. WebKit also
-  // releases the page's own locks, so a restored page would work with state
-  // the other tabs gave up on. The page therefore ends its part as if it
-  // closed, and reloads when it is shown again.
+  // A page entering the back-forward cache is frozen with its DbWorkers, and
+  // WebKit keeps their database locks while the page is cached
+  // (https://bugs.webkit.org/show_bug.cgi?id=316904), so the other tabs would
+  // stall. WebKit also releases the page's own locks, so a restored page would
+  // work with state the other tabs gave up on. The page therefore ends its part
+  // as if it closed, and reloads when it is shown again.
   const reloadRestoredPage = (event: PageTransitionEvent): void => {
     if (event.persisted) reloadThisApp();
   };