@zeronsh/orbit 0.3.3 → 0.3.5

package/dist/{chunk-BJPEQCCN.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;
@@ -521,6 +521,20 @@ var Store = class {
   pendingMutations() {
     return this.#pending.map((p) => p.mutation).filter((m) => m !== void 0);
   }
+  /** Drop a single pending mutation by id — e.g. an undeliverable "poison" mutation
+   *  the server keeps rejecting (oversized frame). Removes its optimistic overlay and,
+   *  on the next flush, its persisted `p/` entry, so it is neither replayed on reconnect
+   *  nor restored on reload. Returns whether such a mutation was present. */
+  dropPending(id) {
+    const idx = this.#pending.findIndex((p2) => p2.id === id);
+    if (idx === -1) return false;
+    const [p] = this.#pending.splice(idx, 1);
+    this.#dirtyPending.add(p.id);
+    for (const op of p.ops) this.#touch(op.tableName, this.#key(op.tableName, op.value));
+    this.#scheduleFlush();
+    this.#notify();
+    return true;
+  }
   /** All rows for `table` with the optimistic overlay applied. */
   effectiveRows(table2) {
     const merged = new Map(this.#table(table2));
@@ -592,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;
     }
@@ -638,6 +659,22 @@ function typeRank(v) {
       return 4;
   }
 }
+function compareStringsUtf8(a, b) {
+  if (a === b) return 0;
+  const ia = a[Symbol.iterator]();
+  const ib = b[Symbol.iterator]();
+  for (; ; ) {
+    const na = ia.next();
+    const nb = ib.next();
+    if (na.done) return nb.done ? 0 : -1;
+    if (nb.done) return 1;
+    if (na.value !== nb.value) {
+      const ca = na.value.codePointAt(0);
+      const cb = nb.value.codePointAt(0);
+      if (ca !== cb) return ca < cb ? -1 : 1;
+    }
+  }
+}
 function compareValues(a, b) {
   if (isNull(a) && isNull(b)) return 0;
   if (isNull(a)) return -1;
@@ -645,7 +682,7 @@ function compareValues(a, b) {
   if (typeof a === typeof b) {
     if (typeof a === "number") return a < b ? -1 : a > b ? 1 : 0;
     if (typeof a === "boolean") return a === b ? 0 : a ? 1 : -1;
-    if (typeof a === "string") return a < b ? -1 : a > b ? 1 : 0;
+    if (typeof a === "string") return compareStringsUtf8(a, b);
     return 0;
   }
   return typeRank(a) - typeRank(b);
@@ -1679,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;
@@ -1797,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. */
@@ -1804,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);
@@ -1851,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;
@@ -1874,10 +1950,29 @@ var Orbit = class {
     ws.addEventListener("message", (ev) => {
       this.#onMessage(JSON.parse(ev.data));
     });
-    ws.addEventListener("close", () => {
+    ws.addEventListener("close", (ev) => {
       this.#connecting = false;
       if (this.#ws === ws) this.#ws = void 0;
       this.#poke = null;
+      if (ev.code === 1009 && this.#unconfirmedPushes.size > 0) {
+        let poisonId;
+        let maxSize = -1;
+        for (const [id, msg] of this.#unconfirmedPushes) {
+          const size = JSON.stringify(msg).length;
+          if (size > maxSize) {
+            maxSize = size;
+            poisonId = id;
+          }
+        }
+        if (poisonId !== void 0) {
+          this.#unconfirmedPushes.delete(poisonId);
+          this.#store.dropPending(poisonId);
+          this.#onError?.({
+            kind: "mutation-too-large",
+            message: `dropped mutation ${poisonId} (~${maxSize} bytes): server closed with code 1009 (message too big)`
+          });
+        }
+      }
       this.#scheduleReconnect();
     });
     ws.addEventListener("error", () => ws.close());
@@ -1955,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) => {
@@ -1987,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-BJPEQCCN.js.map
-//# sourceMappingURL=chunk-BJPEQCCN.js.map
+//# sourceMappingURL=chunk-B575ZNM2.js.map
+//# sourceMappingURL=chunk-B575ZNM2.js.map