@rocicorp/zero 0.17.2025030600 → 0.17.2025030601

package/out/{chunk-XXZWDMNW.js → chunk-EENFDWT4.js}

@@ -3661,7 +3661,7 @@ async function* scanForHash(expectedRootHash, getRootHash, hash2, fromKey, readN
   }
 }
 async function allEntriesAsDiff(map, op) {
-  const diff2 = [];
+  const diff3 = [];
   const make = op === "add" ? (entry) => ({
     op: "add",
     key: entry[0],
@@ -3672,9 +3672,9 @@ async function allEntriesAsDiff(map, op) {
     oldValue: entry[1]
   });
   for await (const entry of map.entries()) {
-    diff2.push(make(entry));
+    diff3.push(make(entry));
   }
-  return diff2;
+  return diff3;
 }
 
 // ../replicache/src/db/index-operation-enum.ts
@@ -3843,10 +3843,6 @@ async function readFromHead(name, dagRead, formatVersion) {
   const commit = await commitFromHead(name, dagRead);
   return readFromCommit(commit, dagRead, formatVersion);
 }
-async function readFromHash(hash2, dagRead, formatVersion) {
-  const commit = await commitFromHash(hash2, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
-}
 function readFromCommit(commit, dagRead, formatVersion) {
   const indexes = readIndexesForRead(commit, dagRead, formatVersion);
   const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);
@@ -4391,6 +4387,13 @@ var DiffsMap = class extends Map {
     return super.set(key, value);
   }
 };
+async function diff2(oldHash, newHash, read, diffConfig, formatVersion) {
+  const [oldCommit, newCommit] = await Promise.all([
+    commitFromHash(oldHash, read),
+    commitFromHash(newHash, read)
+  ]);
+  return diffCommits(oldCommit, newCommit, read, diffConfig, formatVersion);
+}
 async function diffCommits(oldCommit, newCommit, read, diffConfig, formatVersion) {
   const diffsMap = new DiffsMap();
   if (!diffConfig.shouldComputeDiffs()) {
@@ -5053,29 +5056,10 @@ var CookieMismatch = 2;
 
 // ../replicache/src/sync/patch.ts
 async function apply(lc, dbWrite, patch) {
-  const ret = [];
-  function pushChangeOrAdd(key, oldValue, newValue) {
-    if (oldValue === void 0) {
-      ret.push({
-        op: "add",
-        key,
-        newValue
-      });
-    } else {
-      ret.push({
-        op: "change",
-        key,
-        oldValue,
-        newValue
-      });
-    }
-  }
   for (const p of patch) {
     switch (p.op) {
       case "put": {
-        const existing = await dbWrite.get(p.key);
         const frozen = deepFreeze(p.value);
-        pushChangeOrAdd(p.key, existing, frozen);
         await dbWrite.put(lc, p.key, frozen);
         break;
       }
@@ -5097,7 +5081,6 @@ async function apply(lc, dbWrite, patch) {
           addToEntries(p.merge);
         }
         const frozen = deepFreeze(Object.fromEntries(entries));
-        pushChangeOrAdd(p.key, existing, frozen);
         await dbWrite.put(lc, p.key, frozen);
         break;
       }
@@ -5107,22 +5090,13 @@ async function apply(lc, dbWrite, patch) {
           continue;
         }
         await dbWrite.del(lc, p.key);
-        ret.push({
-          op: "del",
-          key: p.key,
-          oldValue: existing
-        });
         break;
       }
       case "clear":
         await dbWrite.clear();
-        ret.push({
-          op: "clear"
-        });
         break;
     }
   }
-  return ret;
 }
 
 // ../replicache/src/sync/pull-error.ts
@@ -5289,11 +5263,10 @@ function handlePullResponseV1(lc, store, expectedBaseCookie, response, clientID,
       clientID,
       formatVersion
     );
-    const diffs = await apply(lc, dbWrite, response.patch);
+    await apply(lc, dbWrite, response.patch);
     return {
       type: Applied,
-      syncHead: await dbWrite.commit(SYNC_HEAD_NAME),
-      diffs
+      syncHead: await dbWrite.commit(SYNC_HEAD_NAME)
     };
   });
 }
@@ -6774,8 +6747,8 @@ var SubscriptionImpl = class {
     return this.#body(tx);
   }
   matches(diffs) {
-    for (const [indexName, diff2] of diffs) {
-      if (diffMatchesSubscription(this.#keys, this.#scans, indexName, diff2)) {
+    for (const [indexName, diff3] of diffs) {
+      if (diffMatchesSubscription(this.#keys, this.#scans, indexName, diff3)) {
         return true;
       }
     }
@@ -6815,7 +6788,7 @@ var WatchSubscription = class {
   }
   invoke(tx, kind, diffs) {
     const invoke = async (indexName, prefix, compareKey, convertInternalDiff) => {
-      let diff2;
+      let diff3;
       if (kind === InitialRun) {
         if (!this.#initialValuesInFirstDiff) {
           return void 0;
@@ -6829,17 +6802,17 @@ var WatchSubscription = class {
             newValue: entry[1]
           });
         }
-        diff2 = newDiff2;
+        diff3 = newDiff2;
       } else {
         assert(diffs);
         const maybeDiff = diffs.get(indexName ?? "") ?? [];
-        diff2 = convertInternalDiff(maybeDiff);
+        diff3 = convertInternalDiff(maybeDiff);
       }
       const newDiff = [];
-      const { length } = diff2;
-      for (let i = diffBinarySearch(diff2, prefix, compareKey); i < length; i++) {
-        if (compareKey(diff2[i]).startsWith(prefix)) {
-          newDiff.push(diff2[i]);
+      const { length } = diff3;
+      for (let i = diffBinarySearch(diff3, prefix, compareKey); i < length; i++) {
+        if (compareKey(diff3[i]).startsWith(prefix)) {
+          newDiff.push(diff3[i]);
         } else {
           break;
         }
@@ -6850,29 +6823,29 @@ var WatchSubscription = class {
       return invoke(
         this.#indexName,
         this.#prefix,
-        (diff2) => diff2.key[0],
+        (diff3) => diff3.key[0],
         (internalDiff) => convertDiffValues(internalDiff, decodeIndexKey)
       );
     }
     return invoke(
       void 0,
       this.#prefix,
-      (diff2) => diff2.key,
+      (diff3) => diff3.key,
       (internalDiff) => convertDiffValues(internalDiff, (k) => k)
     );
   }
   matches(diffs) {
-    const diff2 = diffs.get(this.#indexName ?? "");
-    if (diff2 === void 0) {
+    const diff3 = diffs.get(this.#indexName ?? "");
+    if (diff3 === void 0) {
       return false;
     }
-    return watcherMatchesDiff(diff2, this.#prefix, this.#indexName);
+    return watcherMatchesDiff(diff3, this.#prefix, this.#indexName);
   }
   updateDeps(_keys, _scans) {
   }
 };
-function convertDiffValues(diff2, convertKey) {
-  return diff2.map((op) => {
+function convertDiffValues(diff3, convertKey) {
+  return diff3.map((op) => {
     const key = convertKey(op.key);
     switch (op.op) {
       case "add":
@@ -6991,23 +6964,23 @@ var SubscriptionsManagerImpl = class {
     return false;
   }
 };
-function diffMatchesSubscription(keys, scans, indexName, diff2) {
+function diffMatchesSubscription(keys, scans, indexName, diff3) {
   if (indexName === "") {
-    for (const diffEntry of diff2) {
+    for (const diffEntry of diff3) {
       if (keys.has(diffEntry.key)) {
         return true;
       }
     }
   }
   for (const scanInfo of scans) {
-    if (scanInfoMatchesDiff(scanInfo, indexName, diff2)) {
+    if (scanInfoMatchesDiff(scanInfo, indexName, diff3)) {
       return true;
     }
   }
   return false;
 }
-function scanInfoMatchesDiff(scanInfo, changeIndexName, diff2) {
-  for (const diffEntry of diff2) {
+function scanInfoMatchesDiff(scanInfo, changeIndexName, diff3) {
+  for (const diffEntry of diff3) {
     if (scanInfoMatchesKey(scanInfo, changeIndexName, diffEntry.key)) {
       return true;
     }
@@ -7069,18 +7042,18 @@ function* subscriptionsForDiffs(subscriptions, diffs) {
     }
   }
 }
-function watcherMatchesDiff(diff2, prefix, indexName) {
+function watcherMatchesDiff(diff3, prefix, indexName) {
   if (prefix === "") {
     return true;
   }
   const compareKey = indexName ? (diffOp) => decodeIndexKey(diffOp.key)[0] : (diffOp) => diffOp.key;
-  const i = diffBinarySearch(diff2, prefix, compareKey);
-  return i < diff2.length && compareKey(diff2[i]).startsWith(prefix);
+  const i = diffBinarySearch(diff3, prefix, compareKey);
+  return i < diff3.length && compareKey(diff3[i]).startsWith(prefix);
 }
-function diffBinarySearch(diff2, prefix, compareKey) {
+function diffBinarySearch(diff3, prefix, compareKey) {
   return binarySearch(
-    diff2.length,
-    (i) => compareUTF82(prefix, compareKey(diff2[i]))
+    diff3.length,
+    (i) => compareUTF82(prefix, compareKey(diff3[i]))
   );
 }
 
@@ -7832,7 +7805,7 @@ var ReplicacheImpl = class {
    *
    * @experimental This method is under development and its semantics will change.
    */
-  async poke(poke, pullApplied) {
+  async poke(poke) {
     await this.#ready;
     const { clientID } = this;
     const requestID = newRequestID(clientID);
@@ -7856,7 +7829,6 @@ var ReplicacheImpl = class {
     );
     switch (result.type) {
       case Applied:
-        await pullApplied(this.memdag, result.syncHead, result.diffs);
         await this.maybeEndPull(result.syncHead, requestID);
         break;
       case CookieMismatch:
@@ -13265,101 +13237,15 @@ function sourceNameFromKey(key) {
   return key.slice(ENTITIES_KEY_PREFIX.length, slash);
 }
 
-// ../zero-client/src/client/ivm-source-repo.ts
-var IVMSourceRepo = class {
-  #main;
-  #tables;
-  /**
-   * Sync is lazily created when the first response from the server is received.
-   */
-  #sync;
-  /**
-   * Rebase is created when the sync head is advanced and points to a fork
-   * of the sync head. This is used to rebase optimistic mutations.
-   */
-  #rebase;
-  constructor(tables) {
-    this.#main = new IVMSourceBranch(tables);
-    this.#tables = tables;
-  }
-  get main() {
-    return this.#main;
-  }
-  /**
-   * Used for reads in `zero.TransactionImpl`.
-   * Writes in `zero.TransactionImpl` also get applied to the rebase branch.
-   *
-   * The rebase branch is always forked off of the sync branch when a rebase begins.
-   */
-  get rebase() {
-    return must(this.#rebase, "rebase branch does not exist!");
-  }
-  advanceSyncHead = async (store, syncHeadHash, patches) => {
-    if (this.#sync === void 0) {
-      await withRead(store, async (dagRead) => {
-        const syncSources = new IVMSourceBranch(this.#tables);
-        const read = await readFromHash(
-          syncHeadHash,
-          dagRead,
-          Latest
-        );
-        for await (const entry of read.map.scan(ENTITIES_KEY_PREFIX)) {
-          if (!entry[0].startsWith(ENTITIES_KEY_PREFIX)) {
-            break;
-          }
-          const name = sourceNameFromKey(entry[0]);
-          const source = must(syncSources.getSource(name));
-          source.push({
-            type: "add",
-            row: entry[1]
-          });
-        }
-        this.#sync = syncSources;
-      });
-    } else {
-      for (const patch of patches) {
-        if (patch.op === "clear") {
-          this.#sync.clear();
-          continue;
-        }
-        const { key } = patch;
-        if (!key.startsWith(ENTITIES_KEY_PREFIX)) {
-          continue;
-        }
-        const name = sourceNameFromKey(key);
-        const source = must(this.#sync.getSource(name));
-        switch (patch.op) {
-          case "del":
-            source.push({
-              type: "remove",
-              row: patch.oldValue
-            });
-            break;
-          case "add":
-            source.push({
-              type: "add",
-              row: patch.newValue
-            });
-            break;
-          case "change":
-            source.push({
-              type: "edit",
-              row: patch.newValue,
-              oldRow: patch.oldValue
-            });
-            break;
-        }
-      }
-    }
-    this.#rebase = must(this.#sync).fork();
-  };
-};
+// ../zero-client/src/client/ivm-branch.ts
 var IVMSourceBranch = class _IVMSourceBranch {
   #sources;
   #tables;
-  constructor(tables, sources = /* @__PURE__ */ new Map()) {
+  hash;
+  constructor(tables, hash2, sources = /* @__PURE__ */ new Map()) {
     this.#tables = tables;
     this.#sources = sources;
+    this.hash = hash2;
   }
   getSource(name) {
     if (this.#sources.has(name)) {
@@ -13373,20 +13259,46 @@ var IVMSourceBranch = class _IVMSourceBranch {
   clear() {
     this.#sources.clear();
   }
+  /**
+   * Mutates the current branch, advancing it to the new head
+   * by applying the given diffs.
+   */
+  advance(expectedHead, newHead, diffs) {
+    assert(
+      this.hash === expectedHead,
+      () => `Expected head must match the main head. Got: ${this.hash}, expected: ${expectedHead}`
+    );
+    applyDiffs(diffs, this);
+    this.hash = newHead;
+  }
+  /**
+   * Fork the branch and patch it up to match the desired head.
+   */
+  async forkToHead(store, expectedHead, desiredHead) {
+    const fork = this.fork();
+    assert(
+      expectedHead === fork.hash,
+      () => `Expected head must match the main head. Got: ${expectedHead}, expected: ${fork.hash}`
+    );
+    if (fork.hash === desiredHead) {
+      return fork;
+    }
+    await patchBranch(desiredHead, store, fork);
+    fork.hash = desiredHead;
+    return fork;
+  }
   /**
    * Creates a new IVMSourceBranch that is a copy of the current one.
    * This is a cheap operation since the b-trees are shared until a write is performed
    * and then only the modified nodes are copied.
    *
-   * This is used when:
-   * 1. We need to rebase a change. We fork the `sync` branch and run the mutations against the fork.
-   * 2. We need to create `main` at startup.
-   * 3. We need to create a new `sync` head because we got a new server snapshot.
-   *    The old `sync` head is forked and the new server snapshot is applied to the fork.
+   * IVM branches are forked when we need to rebase mutations.
+   * The mutations modify the fork rather than original branch.
    */
   fork() {
     return new _IVMSourceBranch(
       this.#tables,
+      this.hash,
       new Map(
         wrapIterable(this.#sources.entries()).map(([name, source]) => [
           name,
@@ -13396,6 +13308,61 @@ var IVMSourceBranch = class _IVMSourceBranch {
     );
   }
 };
+async function patchBranch(desiredHead, store, fork) {
+  const diffs = await computeDiffs(must(fork.hash), desiredHead, store);
+  if (!diffs) {
+    return;
+  }
+  applyDiffs(diffs, fork);
+}
+async function computeDiffs(startHash, endHash, store) {
+  const readFn = (dagRead) => diff2(
+    startHash,
+    endHash,
+    dagRead,
+    {
+      shouldComputeDiffs: () => true,
+      shouldComputeDiffsForIndex(_name) {
+        return false;
+      }
+    },
+    Latest
+  );
+  const diffs = await withRead(store, readFn);
+  return diffs.get("");
+}
+function applyDiffs(diffs, branch) {
+  for (let i = diffBinarySearch(diffs, ENTITIES_KEY_PREFIX, (diff3) => diff3.key); i < diffs.length; i++) {
+    const diff3 = diffs[i];
+    const { key } = diff3;
+    if (!key.startsWith(ENTITIES_KEY_PREFIX)) {
+      break;
+    }
+    const name = sourceNameFromKey(key);
+    const source = must(branch.getSource(name));
+    switch (diff3.op) {
+      case "del":
+        source.push({
+          type: "remove",
+          row: diff3.oldValue
+        });
+        break;
+      case "add":
+        source.push({
+          type: "add",
+          row: diff3.newValue
+        });
+        break;
+      case "change":
+        source.push({
+          type: "edit",
+          row: diff3.newValue,
+          oldRow: diff3.oldValue
+        });
+        break;
+    }
+  }
+}
 
 // ../zero-client/src/client/context.ts
 var ZeroContext = class {
@@ -13444,40 +13411,40 @@ var ZeroContext = class {
   processChanges(changes) {
     this.batchViewUpdates(() => {
       try {
-        for (const diff2 of changes) {
-          const { key } = diff2;
+        for (const diff3 of changes) {
+          const { key } = diff3;
           assert(key.startsWith(ENTITIES_KEY_PREFIX));
           const name = sourceNameFromKey(key);
           const source = this.getSource(name);
           if (!source) {
             continue;
           }
-          switch (diff2.op) {
+          switch (diff3.op) {
             case "del":
-              assert(typeof diff2.oldValue === "object");
+              assert(typeof diff3.oldValue === "object");
               source.push({
                 type: "remove",
-                row: diff2.oldValue
+                row: diff3.oldValue
               });
               break;
             case "add":
-              assert(typeof diff2.newValue === "object");
+              assert(typeof diff3.newValue === "object");
               source.push({
                 type: "add",
-                row: diff2.newValue
+                row: diff3.newValue
               });
               break;
             case "change":
-              assert(typeof diff2.newValue === "object");
-              assert(typeof diff2.oldValue === "object");
+              assert(typeof diff3.newValue === "object");
+              assert(typeof diff3.oldValue === "object");
               source.push({
                 type: "edit",
-                row: diff2.newValue,
-                oldRow: diff2.oldValue
+                row: diff3.newValue,
+                oldRow: diff3.oldValue
               });
               break;
             default:
-              unreachable(diff2);
+              unreachable(diff3);
           }
         }
       } finally {
@@ -13713,23 +13680,13 @@ async function deleteImpl(tx, arg, schema, ivmBranch) {
 
 // ../zero-client/src/client/custom.ts
 var TransactionImpl = class {
-  constructor(repTx, schema, ivmSourceRepo) {
+  constructor(repTx, schema) {
     must(repTx.reason === "initial" || repTx.reason === "rebase");
     this.clientID = repTx.clientID;
     this.mutationID = repTx.mutationID;
     this.reason = repTx.reason === "initial" ? "optimistic" : "rebase";
-    this.mutate = makeSchemaCRUD(
-      schema,
-      repTx,
-      // Mutators do not write to the main IVM sources during optimistic mutations
-      // so we pass undefined here.
-      // ExperimentalWatch handles updating main.
-      this.reason === "optimistic" ? void 0 : ivmSourceRepo.rebase
-    );
-    this.query = makeSchemaQuery(
-      schema,
-      this.reason === "optimistic" ? ivmSourceRepo.main : ivmSourceRepo.rebase
-    );
+    this.mutate = makeSchemaCRUD(schema, repTx);
+    this.query = {};
   }
   clientID;
   mutationID;
@@ -13738,33 +13695,20 @@ var TransactionImpl = class {
   mutate;
   query;
 };
-function makeReplicacheMutator(mutator, schema, ivmSourceRepo) {
+function makeReplicacheMutator(mutator, schema) {
   return (repTx, args) => {
-    const tx = new TransactionImpl(repTx, schema, ivmSourceRepo);
+    const tx = new TransactionImpl(repTx, schema);
     return mutator(tx, args);
   };
 }
-function makeSchemaQuery(schema, ivmBranch) {
-  const rv = {};
-  const context = new ZeroContext(
-    ivmBranch,
-    () => () => {
-    },
-    (applyViewUpdates) => applyViewUpdates()
-  );
-  for (const name of Object.keys(schema.tables)) {
-    rv[name] = newQuery(context, schema, name);
-  }
-  return rv;
-}
-function makeSchemaCRUD(schema, tx, ivmBranch) {
+function makeSchemaCRUD(schema, tx) {
   const mutate = {};
   for (const [name] of Object.entries(schema.tables)) {
-    mutate[name] = makeTableCRUD(schema, name, tx, ivmBranch);
+    mutate[name] = makeTableCRUD(schema, name, tx);
   }
   return mutate;
 }
-function makeTableCRUD(schema, tableName, tx, ivmBranch) {
+function makeTableCRUD(schema, tableName, tx) {
   const table2 = must(schema.tables[tableName]);
   const { primaryKey } = table2;
   return {
@@ -13772,25 +13716,25 @@ function makeTableCRUD(schema, tableName, tx, ivmBranch) {
       tx,
       { op: "insert", tableName, primaryKey, value },
       schema,
-      ivmBranch
+      void 0
     ),
     upsert: (value) => upsertImpl(
       tx,
       { op: "upsert", tableName, primaryKey, value },
       schema,
-      ivmBranch
+      void 0
     ),
     update: (value) => updateImpl(
       tx,
       { op: "update", tableName, primaryKey, value },
       schema,
-      ivmBranch
+      void 0
     ),
     delete: (id) => deleteImpl(
       tx,
       { op: "delete", tableName, primaryKey, value: id },
       schema,
-      ivmBranch
+      void 0
     )
   };
 }
@@ -14094,7 +14038,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.17.2025030600";
+var version2 = "0.17.2025030601";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14407,8 +14351,8 @@ var QueryManager = class {
     this.#recentQueriesMaxSize = recentQueriesMaxSize;
     this.#send = send2;
     experimentalWatch(
-      (diff2) => {
-        for (const diffOp of diff2) {
+      (diff3) => {
+        for (const diffOp of diff3) {
           const queryHash = diffOp.key.substring(GOT_QUERIES_KEY_PREFIX.length);
           switch (diffOp.op) {
             case "add":
@@ -15059,7 +15003,7 @@ var Zero = class {
   #enableAnalytics;
   #pokeHandler;
   #queryManager;
-  #ivmSources;
+  #ivmMain;
   #clientToServer;
   #deleteClientsManager;
   /**
@@ -15191,14 +15135,14 @@ var Zero = class {
     const replicacheMutators = {
       [CRUD_MUTATION_NAME]: makeCRUDMutator(schema)
     };
-    this.#ivmSources = new IVMSourceRepo(schema.tables);
+    this.#ivmMain = new IVMSourceBranch(schema.tables);
     for (const [namespace, mutatorsForNamespace] of Object.entries(
       options.mutators ?? {}
     )) {
       for (const [name, mutator] of Object.entries(
         mutatorsForNamespace
       )) {
-        replicacheMutators[customMutatorKey(namespace, name)] = makeReplicacheMutator(mutator, schema, this.#ivmSources);
+        replicacheMutators[customMutatorKey(namespace, name)] = makeReplicacheMutator(mutator, schema);
       }
     }
     this.storageKey = storageKey ?? "";
@@ -15292,12 +15236,12 @@ var Zero = class {
       this.#lc
     );
     this.#zeroContext = new ZeroContext(
-      this.#ivmSources.main,
+      this.#ivmMain,
       (ast, ttl, gotCallback) => this.#queryManager.add(ast, ttl, gotCallback),
       batchViewUpdates
     );
     rep.experimentalWatch(
-      (diff2) => this.#zeroContext.processChanges(diff2),
+      (diff3) => this.#zeroContext.processChanges(diff3),
       {
         prefix: ENTITIES_KEY_PREFIX,
         initialValuesInFirstDiff: true
@@ -15314,7 +15258,7 @@ var Zero = class {
     });
     this.#metrics.tags.push(`version:${this.version}`);
     this.#pokeHandler = new PokeHandler(
-      (poke) => this.#rep.poke(poke, this.#ivmSources.advanceSyncHead),
+      (poke) => this.#rep.poke(poke),
       () => this.#onPokeError(),
       rep.clientID,
       schema,
@@ -16298,4 +16242,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-XXZWDMNW.js.map
+//# sourceMappingURL=chunk-EENFDWT4.js.map