@zeronsh/orbit 0.3.4 → 0.3.6

package/dist/{chunk-LUFJQUF4.js → chunk-B575ZNM2.js}

@@ -407,7 +407,7 @@ var Store = class {
   // persistence
   #kv;
   #dirtyRows = /* @__PURE__ */ new Set();
-  // "tablepkKey"
+  // `${table}\u0000${pkKey}` (NUL separator: cannot appear in a table name)
   #dirtyPending = /* @__PURE__ */ new Set();
   #cleared = false;
   #flushTimer;
@@ -606,29 +606,36 @@ var Store = class {
     }
     const kv = this.#kv;
     if (!kv) return;
+    const clearOps = [];
     if (this.#cleared) {
-      const dels = [];
-      for (const [k] of await kv.entries("e/")) dels.push(kv.del(k));
-      await Promise.all(dels);
+      for (const [k] of await kv.entries("e/")) clearOps.push({ type: "del", key: k });
       this.#cleared = false;
     }
-    const ps = [];
+    const ops = [];
     for (const dk of this.#dirtyRows) {
       const sep = dk.indexOf("\0");
       const table2 = dk.slice(0, sep);
       const pkKey2 = dk.slice(sep + 1);
       const row = this.#tables.get(table2)?.get(pkKey2);
       const key = `e/${table2}/${pkKey2}`;
-      ps.push(row ? kv.set(key, { t: table2, k: pkKey2, v: row }) : kv.del(key));
+      ops.push(row ? { type: "set", key, value: { t: table2, k: pkKey2, v: row } } : { type: "del", key });
     }
     this.#dirtyRows.clear();
     for (const id of this.#dirtyPending) {
       const p = this.#pending.find((x) => x.id === id);
-      ps.push(p ? kv.set(`p/${id}`, p) : kv.del(`p/${id}`));
+      ops.push(p ? { type: "set", key: `p/${id}`, value: p } : { type: "del", key: `p/${id}` });
     }
     this.#dirtyPending.clear();
-    await Promise.all(ps);
-    if (this.#cookieDirty && this.#cookie !== void 0) {
+    const cookieDirty = this.#cookieDirty && this.#cookie !== void 0;
+    if (kv.batch) {
+      if (cookieDirty) ops.push({ type: "set", key: "cookie", value: this.#cookie });
+      await kv.batch([...clearOps, ...ops]);
+      if (cookieDirty) this.#cookieDirty = false;
+      return;
+    }
+    await Promise.all(clearOps.map((o) => kv.del(o.key)));
+    await Promise.all(ops.map((o) => o.type === "set" ? kv.set(o.key, o.value) : kv.del(o.key)));
+    if (cookieDirty) {
       await kv.set("cookie", this.#cookie);
       this.#cookieDirty = false;
     }
@@ -1709,6 +1716,8 @@ var Orbit = class {
   #onError;
   /** Whether the id was supplied explicitly (then we never override it from the KV). */
   #idFromOpts;
+  /** Releases the Web-Locks persistence leadership (held by the first tab). */
+  #releasePersistLock;
   constructor(opts) {
     this.#opts = opts;
     this.#schema = opts.schema;
@@ -1827,6 +1836,7 @@ var Orbit = class {
   close() {
     this.#closed = true;
     this.#ws?.close();
+    this.#releasePersistLock?.();
   }
   // --- internals ----------------------------------------------------------
   /** Resolve the client context (a value or sync getter); `{}` when unset. */
@@ -1834,8 +1844,39 @@ var Orbit = class {
     const c = this.#context;
     return typeof c === "function" ? c() : c ?? {};
   }
+  /**
+   * Web-Locks single-writer election for the persisted cache. Two tabs sharing one
+   * IndexedDB (and the restored clientID) would each flush their own dirty rows,
+   * pending mutations, and cookie into the same flat keyspace with no coordination —
+   * last-writer-wins can persist a cookie covering rows only the *other* tab wrote,
+   * and both tabs would drive the same server-side CVR. Only the first tab (the
+   * lock holder) gets persistence; later tabs run memory-only with their own fresh
+   * clientID (a full server sync — correct, just uncached). The lock auto-releases
+   * when the tab dies, so the next reload elects a new leader. Environments without
+   * Web Locks (Node, tests, old browsers) keep today's behavior.
+   */
+  async #acquirePersistLock() {
+    const locks = globalThis.navigator?.locks;
+    if (!locks) return true;
+    return new Promise((resolve2) => {
+      const req = locks.request("zeronsh-orbit-persist", { ifAvailable: true }, (lock) => {
+        if (lock === null) {
+          resolve2(false);
+          return;
+        }
+        resolve2(true);
+        return new Promise((release) => {
+          this.#releasePersistLock = release;
+        });
+      });
+      void Promise.resolve(req).catch(() => resolve2(true));
+    });
+  }
   /** Hydrate persisted state (if any), restore unconfirmed mutations, then connect. */
   async #init() {
+    if (this.#kv && !await this.#acquirePersistLock()) {
+      this.#kv = void 0;
+    }
     if (this.#kv) {
       try {
         await this.#store.hydrate(this.#kv);
@@ -1881,8 +1922,13 @@ var Orbit = class {
       requestID: Math.random().toString(36).slice(2)
     }];
     this.#unconfirmedPushes.set(id, msg);
-    void this.#kv?.set("nextMutationID", this.#nextMutationID);
-    this.#send(msg);
+    const kv = this.#kv;
+    if (kv) {
+      void kv.set("nextMutationID", this.#nextMutationID).catch(() => {
+      }).then(() => this.#send(msg));
+    } else {
+      this.#send(msg);
+    }
   }
   async #connect() {
     if (this.#closed || this.#connecting) return;
@@ -2004,6 +2050,12 @@ var MemoryKV = class {
   async entries(prefix) {
     return [...this.#m].filter(([k]) => k.startsWith(prefix));
   }
+  async batch(ops) {
+    for (const op of ops) {
+      if (op.type === "set") this.#m.set(op.key, op.value);
+      else this.#m.delete(op.key);
+    }
+  }
 };
 function wrap(req) {
   return new Promise((resolve2, reject) => {
@@ -2036,16 +2088,33 @@ var IDBKV = class {
   }
   async entries(prefix) {
     const s = await this.#store("readonly");
-    const [keys, vals] = await Promise.all([wrap(s.getAllKeys()), wrap(s.getAll())]);
-    const out = [];
-    for (let i = 0; i < keys.length; i++) {
-      const k = String(keys[i]);
-      if (k.startsWith(prefix)) out.push([k, vals[i]]);
-    }
-    return out;
+    const successor = prefix.slice(0, -1) + String.fromCharCode(prefix.charCodeAt(prefix.length - 1) + 1);
+    const range = IDBKeyRange.bound(prefix, successor, false, true);
+    const [keys, vals] = await Promise.all([wrap(s.getAllKeys(range)), wrap(s.getAll(range))]);
+    return keys.map((k, i) => [String(k), vals[i]]);
+  }
+  /**
+   * All ops in ONE readwrite transaction: atomic under a crash (IndexedDB
+   * transactions are all-or-nothing) and one commit instead of one per key —
+   * the flush of a large poke goes from N transactions to 1.
+   */
+  async batch(ops) {
+    if (ops.length === 0) return;
+    const db = await this.#dbp;
+    await new Promise((resolve2, reject) => {
+      const tx = db.transaction("kv", "readwrite");
+      const s = tx.objectStore("kv");
+      for (const op of ops) {
+        if (op.type === "set") s.put(op.value, op.key);
+        else s.delete(op.key);
+      }
+      tx.oncomplete = () => resolve2();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error);
+    });
   }
 };
 
 export { IDBKV, MaterializedView, MemoryKV, MemorySource, MemorySourceProvider, Orbit, PROTOCOL_VERSION, Query, QueryManager, SchemaQuery, SourceConnection, Store, StoreProvider, TypedQuery, View, boolean, buildPipeline, buildSchemaQueries, collectOps, compareValues, createBuilder, createOrbitApi, createSchema, defineMutation, defineQuery, evaluate, hashAST, hashString, json, nodeToRow, number, optional, parseTTL, relationships, string, table, tablesOf, unwrapSingular, validateArgs, valuesEqual };
-//# sourceMappingURL=chunk-LUFJQUF4.js.map
-//# sourceMappingURL=chunk-LUFJQUF4.js.map
+//# sourceMappingURL=chunk-B575ZNM2.js.map
+//# sourceMappingURL=chunk-B575ZNM2.js.map