@syncular/client 0.30.10 → 0.30.11

package/src/wasm-database.ts

@@ -22,6 +22,7 @@
  * `ClientDatabase`. Browser-only — exercised by the demo, never imported
  * by bun tests (subpath export `@syncular/client/wasm`).
  */
+import { webLocksLeaderLock, type LeaderLease } from './leader-lock';
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
 import {
   assertImageAlias,
@@ -56,6 +57,8 @@ interface SahPoolUtil {
   /** RFC 0005: the runtime exposes naming and removal on the pool util. */
   getFileNames(): string[];
   unlink(filename: string): boolean;
+  pauseVfs(): unknown;
+  unpauseVfs(): Promise<unknown>;
 }
 
 interface SqliteIoMethods {
@@ -122,13 +125,16 @@ class WasmClientDatabase implements ClientDatabase {
   readonly #db: Oo1Database;
   readonly #sqlite3: Sqlite3Static;
   /** RFC 0005: present only for a persistent OPFS database. */
-  readonly #sah: { readonly util: SahPoolUtil } | undefined;
+  readonly #sah:
+    | { readonly util: SahPoolUtil; readonly lease: LeaderLease }
+    | undefined;
+  #closed = false;
   #tx = { depth: 0 };
 
   constructor(
     db: Oo1Database,
     sqlite3: Sqlite3Static,
-    sah?: { readonly util: SahPoolUtil },
+    sah?: { readonly util: SahPoolUtil; readonly lease: LeaderLease },
   ) {
     this.#db = db;
     this.#sqlite3 = sqlite3;
@@ -236,7 +242,13 @@ class WasmClientDatabase implements ClientDatabase {
   }
 
   close(): void {
+    if (this.#closed) return;
     this.#db.close();
+    // DB.close() leaves the SAH pool live. Close siblings first, then pause the
+    // VFS without deleting files, before releasing this worker's physical lock.
+    this.#sah?.util.pauseVfs();
+    this.#closed = true;
+    void this.#sah?.lease.release();
   }
 }
 
@@ -420,37 +432,52 @@ export async function openPersistentWasmDatabase(
         'in-memory fallback for persistent mode.',
     );
   }
-  const sqlite3 = await initSqlite3();
-  const directory = options?.directory ?? `.syncular/${name}`;
-  let pool = sahPools.get(directory);
-  if (pool === undefined) {
-    pool = sqlite3
-      .installOpfsSAHPoolVfs({
-        // VFS registration names must be unique per directory.
-        name: `syncular-sahpool-${directory.replace(/[^A-Za-z0-9]+/g, '-')}`,
-        directory,
-        // sqlite-wasm caches a rejected initialization promise by VFS name.
-        // Syncular removes its own rejected entry below, so allow a later
-        // open in the same worker to make a real attempt as well.
-        forceReinitIfPreviouslyFailed: true,
-        initialCapacity: Math.max(
-          options?.initialCapacity ?? SAH_POOL_DEFAULT_CAPACITY,
-          SAH_POOL_MIN_CAPACITY,
-        ),
-      })
-      .catch((error: unknown) => {
-        sahPools.delete(directory);
-        throw opfsSahPoolError(error, directory);
-      });
-    sahPools.set(directory, pool);
+  if (!navigator.locks) {
+    throw new ClientSyncError(
+      STORAGE_UNAVAILABLE_CODE,
+      'Persistent OPFS storage requires Web Locks',
+    );
   }
-  const util = await pool;
-  const db = new util.OpfsSAHPoolDb(`/${name}.db`);
+  const directory = (options?.directory ?? `.syncular/${name}`).replace(
+    /^\/+|\/+$/g,
+    '',
+  );
+  // The document's leader lease can end before its worker's SAHs close. This
+  // worker-owned lock has exactly the same lifetime as the physical pool.
+  const lease = await webLocksLeaderLock().acquire(
+    `syncular-opfs/${directory}`,
+  );
+  let util: SahPoolUtil | undefined;
+  let db: Oo1Database | undefined;
   try {
+    const sqlite3 = await initSqlite3();
+    let pool = sahPools.get(directory);
+    if (pool === undefined) {
+      pool = sqlite3
+        .installOpfsSAHPoolVfs({
+          name: `syncular-sahpool-${directory.replace(/[^A-Za-z0-9]+/g, '-')}`,
+          directory,
+          forceReinitIfPreviouslyFailed: true,
+          initialCapacity: Math.max(
+            options?.initialCapacity ?? SAH_POOL_DEFAULT_CAPACITY,
+            SAH_POOL_MIN_CAPACITY,
+          ),
+        })
+        .catch((error: unknown) => {
+          sahPools.delete(directory);
+          throw opfsSahPoolError(error, directory);
+        });
+      sahPools.set(directory, pool);
+    }
+    util = await pool;
+    await util.unpauseVfs();
+    db = new util.OpfsSAHPoolDb(`/${name}.db`);
     configureSahCrashRecovery(db, sqlite3);
-    return new WasmClientDatabase(db, sqlite3, { util });
+    return new WasmClientDatabase(db, sqlite3, { util, lease });
   } catch (error) {
-    db.close();
+    db?.close();
+    util?.pauseVfs();
+    await lease.release();
     throw error;
   }
 }

package/src/worker-host.ts

@@ -804,11 +804,33 @@ async function startWorkerCore(options: {
   const worker = config.worker();
   const pending = new Map<number, Pending>();
   const nextId = { value: 1 };
+  let terminated = false;
+  let rejectReady: ((error: Error) => void) | undefined;
+  const closedError = new ClientSyncError(
+    WORKER_FAILED_CODE,
+    'the handle was closed',
+  );
+  const terminate = () => {
+    if (terminated) return;
+    terminated = true;
+    globalThis.removeEventListener?.('pagehide', terminate);
+    bridge?.close();
+    worker.terminate();
+    rejectReady?.(closedError);
+    for (const entry of pending.values()) entry.reject(closedError);
+    pending.clear();
+    void lease.release();
+  };
+  // Installed before bootstrap starts: pagehide must also terminate a worker
+  // whose first open/import is still pending. Termination closes its SAHs and
+  // releases its physical Web Lock; the next document waits for that lock.
+  globalThis.addEventListener?.('pagehide', terminate);
 
   const invoke = (
     method: string,
     args: readonly unknown[],
   ): Promise<unknown> => {
+    if (terminated) return Promise.reject(closedError);
     const id = nextId.value++;
     return new Promise<unknown>((resolve, reject) => {
       pending.set(id, { resolve, reject });
@@ -824,6 +846,7 @@ async function startWorkerCore(options: {
   let bridge: LeaderBridge | undefined;
 
   const ready = new Promise<void>((resolve, reject) => {
+    rejectReady = reject;
     const onMessage = (event: MessageEvent) => {
       const message = event.data as WorkerToMainMessage;
       switch (message.t) {
@@ -889,26 +912,25 @@ async function startWorkerCore(options: {
       invoke,
       bridge,
       lease,
-      close: async (terminate) => {
+      close: async (terminateWorker) => {
+        if (terminated) return;
         bridge?.close();
         try {
           await invoke('close', []);
         } catch {
-          // Closing a wedged worker still terminates it below.
+          // A terminated or failed worker has no further close RPC to service.
+        }
+        if (terminateWorker) terminate();
+        else {
+          globalThis.removeEventListener?.('pagehide', terminate);
+          for (const entry of pending.values()) entry.reject(closedError);
+          pending.clear();
+          await lease.release();
         }
-        if (terminate) worker.terminate();
-        const closedError = new ClientSyncError(
-          WORKER_FAILED_CODE,
-          'the handle was closed',
-        );
-        for (const entry of pending.values()) entry.reject(closedError);
-        pending.clear();
-        await lease.release();
       },
     };
   } catch (error) {
-    worker.terminate();
-    await lease.release();
+    terminate();
     throw error;
   }
 }