@rocicorp/zero 0.17.2025031200 → 0.17.2025031300

package/out/{chunk-VNV6U5BQ.js → chunk-APXCO5Z2.js}

@@ -3,7 +3,7 @@ import {
   compareTTL,
   hasOwn,
   parseTTL
-} from "./chunk-2Y24MEEQ.js";
+} from "./chunk-5X3DESC6.js";
 import {
   applyChange,
   assert,
@@ -21,7 +21,7 @@ import {
   throwInvalidType,
   unreachable,
   valuesEqual
-} from "./chunk-6CQ6CUML.js";
+} from "./chunk-7ARRNDLF.js";
 import {
   __export,
   __reExport
@@ -2229,7 +2229,7 @@ var LazyStore = class {
     this.#chunkHasher = chunkHasher;
     this.#assertValidHash = assertValidHash;
   }
-  async read() {
+  async read(sourceRead) {
     const release = await this.#rwLock.read();
     return new LazyRead(
       this.#heads,
@@ -2237,7 +2237,8 @@ var LazyStore = class {
       this._sourceChunksCache,
       this.#sourceStore,
       release,
-      this.#assertValidHash
+      this.#assertValidHash,
+      sourceRead
     );
   }
   async write() {
@@ -2276,13 +2277,16 @@ var LazyRead = class {
   #release;
   #closed = false;
   assertValidHash;
-  constructor(heads, memOnlyChunks, sourceChunksCache, sourceStore, release, assertValidHash) {
+  #sourceReadOwnedByCaller;
+  constructor(heads, memOnlyChunks, sourceChunksCache, sourceStore, release, assertValidHash, sourceRead) {
     this._heads = heads;
     this._memOnlyChunks = memOnlyChunks;
     this._sourceChunksCache = sourceChunksCache;
     this._sourceStore = sourceStore;
     this.#release = release;
     this.assertValidHash = assertValidHash;
+    this.#sourceRead = sourceRead !== void 0 ? Promise.resolve(sourceRead) : void 0;
+    this.#sourceReadOwnedByCaller = sourceRead !== void 0;
   }
   isMemOnlyChunkHash(hash2) {
     return this._memOnlyChunks.has(hash2);
@@ -2313,8 +2317,10 @@ var LazyRead = class {
   release() {
     if (!this.#closed) {
       this.#release();
-      this.#sourceRead?.then((read) => read.release()).catch((_) => {
-      });
+      if (!this.#sourceReadOwnedByCaller) {
+        this.#sourceRead?.then((read) => read.release()).catch((_) => {
+        });
+      }
       this.#closed = true;
     }
   }
@@ -3846,6 +3852,10 @@ 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);
@@ -4563,7 +4573,7 @@ var Write = class extends Read {
     const commitHash = (await commit).chunk.hash;
     await this.#dagWrite.setHead(headName, commitHash);
     await this.#dagWrite.commit();
-    return diffMap;
+    return [commitHash, diffMap];
   }
   async #generateDiffs(diffConfig) {
     const diffsMap = new DiffsMap();
@@ -5325,6 +5335,8 @@ function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatV
     if (pending.length > 0) {
       return {
         syncHead: syncHeadHash,
+        oldMainHead: mainHeadHash,
+        mainHead: mainHeadHash,
         replayMutations: pending,
         // The changed keys are not reported when further replays are
         // needed. The diffs will be reported at the end when there
@@ -5361,6 +5373,7 @@ function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatV
       dagWrite.removeHead(SYNC_HEAD_NAME)
     ]);
     await dagWrite.commit();
+    const newMainHeadHash = syncHeadHash;
     if (lc.debug) {
       const [oldLastMutationID, oldCookie] = snapshotMetaParts(
         mainSnapshot,
@@ -5391,6 +5404,8 @@ function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatV
     }
     return {
       syncHead: syncHeadHash,
+      oldMainHead: mainHeadHash,
+      mainHead: newMainHeadHash,
       replayMutations: [],
       diffs: diffsMap
     };
@@ -6236,7 +6251,7 @@ var GatherMemoryOnlyVisitor = class extends Visitor {
 };
 
 // ../replicache/src/persist/persist.ts
-async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, formatVersion, onGatherMemOnlyChunksForTest = () => Promise.resolve()) {
+async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, formatVersion, getZeroData, onGatherMemOnlyChunksForTest = () => Promise.resolve()) {
   if (closed()) {
     return;
   }
@@ -6300,6 +6315,7 @@ async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, forma
     return;
   }
   let memdagBaseSnapshotPersisted = false;
+  const zeroDataForMemdagBaseSnapshot = getZeroData && await getZeroData("rebase", memdagBaseSnapshot.chunk.hash);
   await withWrite(perdag, async (perdagWrite) => {
     const [mainClientGroup, latestPerdagMainClientGroupHeadCommit] = await getClientGroupInfo(perdagWrite, mainClientGroupID);
     let newMainClientGroupHeadHash = latestPerdagMainClientGroupHeadCommit.chunk.hash;
@@ -6345,10 +6361,17 @@ async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, forma
           mutators,
           mutationIDs,
           lc,
-          formatVersion
+          formatVersion,
+          zeroDataForMemdagBaseSnapshot
         );
       }
     }
+    let zeroDataForPerdagHeadCommit;
+    if (!memdagBaseSnapshotPersisted) {
+      zeroDataForPerdagHeadCommit = getZeroData && await getZeroData("rebase", newMainClientGroupHeadHash, {
+        openLazySourceRead: perdagWrite
+      });
+    }
     newMainClientGroupHeadHash = await rebase(
       newMemdagMutations,
       newMainClientGroupHeadHash,
@@ -6356,7 +6379,8 @@ async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, forma
       mutators,
       mutationIDs,
       lc,
-      formatVersion
+      formatVersion,
+      zeroDataForPerdagHeadCommit ?? zeroDataForMemdagBaseSnapshot
     );
     const newMainClientGroup = {
       ...mainClientGroup,
@@ -6378,7 +6402,7 @@ async function getClientGroupInfo(perdagRead, clientGroupID) {
   assert(clientGroup, `No client group for clientGroupID: ${clientGroupID}`);
   return [clientGroup, await commitFromHash(clientGroup.headHash, perdagRead)];
 }
-async function rebase(mutations, basis, write, mutators, mutationIDs, lc, formatVersion) {
+async function rebase(mutations, basis, write, mutators, mutationIDs, lc, formatVersion, zeroData2) {
   for (let i = mutations.length - 1; i >= 0; i--) {
     const mutationCommit = mutations[i];
     const { meta } = mutationCommit;
@@ -6393,7 +6417,7 @@ async function rebase(mutations, basis, write, mutators, mutationIDs, lc, format
         lc,
         meta.clientID,
         formatVersion,
-        void 0
+        zeroData2
       )).chunk.hash;
     }
   }
@@ -6435,7 +6459,7 @@ var GatherNotCachedVisitor = class extends Visitor {
 // ../replicache/src/persist/refresh.ts
 var GATHER_SIZE_LIMIT = 5 * 2 ** 20;
 var DELAY_MS = 300;
-async function refresh(lc, memdag, perdag, clientID, mutators, diffConfig, closed, formatVersion) {
+async function refresh(lc, memdag, perdag, clientID, mutators, diffConfig, closed, formatVersion, zero) {
   if (closed()) {
     return;
   }
@@ -6550,17 +6574,26 @@ async function refresh(lc, memdag, perdag, clientID, mutators, diffConfig, close
       }
       await Promise.all(ps);
       let newMemdagHeadHash = perdagClientGroupHeadHash;
-      for (let i = newMemdagMutations.length - 1; i >= 0; i--) {
-        newMemdagHeadHash = (await rebaseMutationAndPutCommit(
-          newMemdagMutations[i],
-          memdagWrite,
+      if (newMemdagMutations.length > 0) {
+        const zeroData2 = await zero?.getTxData?.(
+          "rebase",
           newMemdagHeadHash,
-          mutators,
-          lc,
-          newMemdagMutations[i].meta.clientID,
-          formatVersion,
-          void 0
-        )).chunk.hash;
+          {
+            openLazyRead: memdagWrite
+          }
+        );
+        for (let i = newMemdagMutations.length - 1; i >= 0; i--) {
+          newMemdagHeadHash = (await rebaseMutationAndPutCommit(
+            newMemdagMutations[i],
+            memdagWrite,
+            newMemdagHeadHash,
+            mutators,
+            lc,
+            newMemdagMutations[i].meta.clientID,
+            formatVersion,
+            zeroData2
+          )).chunk.hash;
+        }
       }
       const newMemdagHeadCommit = await commitFromHash(
         newMemdagHeadHash,
@@ -6577,6 +6610,8 @@ async function refresh(lc, memdag, perdag, clientID, mutators, diffConfig, close
       return {
         type: "complete",
         diffs,
+        oldHead: memdagHeadCommit.chunk.hash,
+        newHead: newMemdagHeadHash,
         newPerdagClientHeadHash: perdagClientGroupHeadHash
       };
     });
@@ -6598,8 +6633,13 @@ async function refresh(lc, memdag, perdag, clientID, mutators, diffConfig, close
     }
     return void 0;
   }
+  zero?.advance(result.oldHead, result.newHead, result.diffs.get("") ?? []);
   await setRefreshHashes([result.newPerdagClientHeadHash]);
-  return result.diffs;
+  return {
+    oldHead: result.oldHead,
+    newHead: result.newHead,
+    diffs: result.diffs
+  };
 }
 function shouldAbortRefresh(memdagBaseSnapshot, perdagClientGroupBaseSnapshot, perdagClientGroupHeadHash) {
   const baseSnapshotCookieCompareResult = compareCookiesForSnapshots(
@@ -7187,6 +7227,7 @@ var ReplicacheImpl = class {
   perdag;
   #idbDatabases;
   #lc;
+  #zero;
   #closeAbortController = new AbortController();
   #persistLock = new Lock2();
   #enableScheduledPersist;
@@ -7296,6 +7337,7 @@ var ReplicacheImpl = class {
       onClientsDeleted = () => {
       }
     } = implOptions;
+    this.#zero = implOptions.zero;
     this.auth = auth ?? "";
     this.pullURL = pullURL;
     this.pushURL = pushURL;
@@ -7401,6 +7443,7 @@ var ReplicacheImpl = class {
       this.memdag,
       (write) => write.setHead(DEFAULT_HEAD_NAME, headHash)
     );
+    await this.#zero?.init(headHash, this.memdag);
     resolveReady();
     if (this.#enablePullAndPushInOpen) {
       this.pull().catch(noop2);
@@ -7567,7 +7610,7 @@ var ReplicacheImpl = class {
       await this.#ready;
       const { clientID } = this;
       const lc = this.#lc.withContext("maybeEndPull").withContext("requestID", requestID);
-      const { replayMutations, diffs } = await maybeEndPull(
+      const { replayMutations, diffs, oldMainHead, mainHead } = await maybeEndPull(
         this.memdag,
         lc,
         syncHead,
@@ -7576,10 +7619,12 @@ var ReplicacheImpl = class {
         Latest
       );
       if (!replayMutations || replayMutations.length === 0) {
+        this.#zero?.advance(oldMainHead, mainHead, diffs.get("") ?? []);
         await this.#subscriptions.fire(diffs);
         void this.#schedulePersist();
         return;
       }
+      const zeroData2 = await this.#zero?.getTxData?.("rebase", syncHead);
       for (const mutation of replayMutations) {
         if (this.#subscriptions.hasPendingSubscriptionRuns) {
           await Promise.resolve();
@@ -7596,7 +7641,7 @@ var ReplicacheImpl = class {
             lc,
             isLocalMetaDD31(meta) ? meta.clientID : clientID,
             Latest,
-            void 0
+            zeroData2
           )
         );
       }
@@ -7908,7 +7953,8 @@ var ReplicacheImpl = class {
           this.perdag,
           this.#mutatorRegistry,
           () => this.#closed,
-          Latest
+          Latest,
+          this.#zero?.getTxData
         );
       } catch (e) {
         if (e instanceof ClientStateNotFoundError) {
@@ -7930,9 +7976,9 @@ var ReplicacheImpl = class {
     if (this.#closed) {
       return;
     }
-    let diffs;
+    let refreshResult;
     try {
-      diffs = await refresh(
+      refreshResult = await refresh(
         this.#lc,
         this.memdag,
         this.perdag,
@@ -7940,7 +7986,8 @@ var ReplicacheImpl = class {
         this.#mutatorRegistry,
         this.#subscriptions,
         () => this.closed,
-        Latest
+        Latest,
+        this.#zero
       );
     } catch (e) {
       if (e instanceof ClientStateNotFoundError) {
@@ -7951,8 +7998,8 @@ var ReplicacheImpl = class {
         throw e;
       }
     }
-    if (diffs !== void 0) {
-      await this.#subscriptions.fire(diffs);
+    if (refreshResult !== void 0) {
+      await this.#subscriptions.fire(refreshResult.diffs);
     }
   }
   #fireOnClientStateNotFound() {
@@ -8143,18 +8190,21 @@ var ReplicacheImpl = class {
           clientID,
           await dbWrite.getMutationID(),
           "initial",
-          void 0,
+          await this.#zero?.getTxData("initial", headHash, {
+            openLazyRead: dagWrite
+          }),
           dbWrite,
           this.#lc
         );
         const result = await mutatorImpl(tx, args);
         throwIfClosed(dbWrite);
         const lastMutationID = await dbWrite.getMutationID();
-        const diffs = await dbWrite.commitWithDiffs(
+        const [newHead, diffs] = await dbWrite.commitWithDiffs(
           DEFAULT_HEAD_NAME,
           this.#subscriptions
         );
         this.lastMutationID = lastMutationID;
+        this.#zero?.advance(headHash, newHead, diffs.get("") ?? []);
         this.#pushConnectionLoop.send(false).catch(() => void 0);
         await this.#subscriptions.fire(diffs);
         void this.#schedulePersist();
@@ -11751,6 +11801,9 @@ var QueryImpl = class extends AbstractQuery {
     );
     return view;
   }
+  updateTTL(ttl) {
+    this.#delegate.updateServerQuery(this._completeAst(), ttl);
+  }
   run() {
     const v2 = this.materialize();
     const ret = v2.data;
@@ -11829,6 +11882,9 @@ var StaticQuery = class _StaticQuery extends AbstractQuery {
   preload() {
     throw new Error("StaticQuery cannot be preloaded");
   }
+  updateTTL(_ttl) {
+    throw new Error("StaticQuery cannot have a TTL");
+  }
 };
 
 // ../zero-schema/src/name-mapper.ts
@@ -13256,6 +13312,21 @@ var MemorySource = class _MemorySource {
     const exists = (row) => data.has(row);
     const setOverlay = (o) => this.#overlay = o;
     const setSplitEditOverlay = (o) => this.#splitEditOverlay = o;
+    if (change.type === "set") {
+      const existing = data.get(change.row);
+      if (existing !== void 0) {
+        change = {
+          type: "edit",
+          row: change.row,
+          oldRow: existing
+        };
+      } else {
+        change = {
+          type: "add",
+          row: change.row
+        };
+      }
+    }
     for (const x of genPush(
       change,
       exists,
@@ -13615,16 +13686,19 @@ var IVMSourceBranch = class _IVMSourceBranch {
   /**
    * Fork the branch and patch it up to match the desired head.
    */
-  async forkToHead(store, expectedHead, desiredHead) {
+  async forkToHead(reason, store, desiredHead, readOptions) {
+    if (reason === "initial") {
+      assert(
+        this.hash === desiredHead,
+        "main branch must be at desired head for `initial`"
+      );
+      return this;
+    }
     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);
+    await patchBranch(desiredHead, store, fork, readOptions);
     fork.hash = desiredHead;
     return fork;
   }
@@ -13649,14 +13723,19 @@ var IVMSourceBranch = class _IVMSourceBranch {
     );
   }
 };
-async function patchBranch(desiredHead, store, fork) {
-  const diffs = await computeDiffs(must(fork.hash), desiredHead, store);
+async function patchBranch(desiredHead, store, fork, readOptions) {
+  const diffs = await computeDiffs(
+    must(fork.hash),
+    desiredHead,
+    store,
+    readOptions
+  );
   if (!diffs) {
     return;
   }
   applyDiffs(diffs, fork);
 }
-async function computeDiffs(startHash, endHash, store) {
+async function computeDiffs(startHash, endHash, store, readOptions) {
   const readFn = (dagRead) => diff2(
     startHash,
     endHash,
@@ -13669,7 +13748,14 @@ async function computeDiffs(startHash, endHash, store) {
     },
     Latest
   );
-  const diffs = await withRead(store, readFn);
+  let diffs;
+  if (readOptions?.openLazySourceRead) {
+    diffs = await using(store.read(readOptions.openLazySourceRead), readFn);
+  } else if (readOptions?.openLazyRead) {
+    diffs = await readFn(readOptions.openLazyRead);
+  } else {
+    diffs = await withRead(store, readFn);
+  }
   return diffs.get("");
 }
 function applyDiffs(diffs, branch) {
@@ -13713,14 +13799,16 @@ var ZeroContext = class {
   // that needs to be fixed.
   #mainSources;
   #addQuery;
+  #updateQuery;
   #batchViewUpdates;
   #commitListeners = /* @__PURE__ */ new Set();
   slowMaterializeThreshold;
   lc;
   staticQueryParameters = void 0;
-  constructor(lc, mainSources, addQuery, batchViewUpdates, slowMaterializeThreshold) {
+  constructor(lc, mainSources, addQuery, updateQuery, batchViewUpdates, slowMaterializeThreshold) {
     this.#mainSources = mainSources;
     this.#addQuery = addQuery;
+    this.#updateQuery = updateQuery;
     this.#batchViewUpdates = batchViewUpdates;
     this.lc = lc;
     this.slowMaterializeThreshold = slowMaterializeThreshold;
@@ -13731,6 +13819,9 @@ var ZeroContext = class {
   addServerQuery(ast, ttl, gotCallback) {
     return this.#addQuery(ast, ttl, gotCallback);
   }
+  updateServerQuery(ast, ttl) {
+    this.#updateQuery(ast, ttl);
+  }
   onQueryMaterialized(hash2, ast, duration) {
     if (this.slowMaterializeThreshold !== void 0 && duration > this.slowMaterializeThreshold) {
       this.lc.warn?.(
@@ -13773,45 +13864,10 @@ var ZeroContext = class {
     );
     return result;
   }
-  processChanges(changes) {
+  processChanges(expectedHead, newHead, changes) {
     this.batchViewUpdates(() => {
       try {
-        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 (diff3.op) {
-            case "del":
-              assert(typeof diff3.oldValue === "object");
-              source.push({
-                type: "remove",
-                row: diff3.oldValue
-              });
-              break;
-            case "add":
-              assert(typeof diff3.newValue === "object");
-              source.push({
-                type: "add",
-                row: diff3.newValue
-              });
-              break;
-            case "change":
-              assert(typeof diff3.newValue === "object");
-              assert(typeof diff3.oldValue === "object");
-              source.push({
-                type: "edit",
-                row: diff3.newValue,
-                oldRow: diff3.oldValue
-              });
-              break;
-            default:
-              unreachable(diff3);
-          }
-        }
+        this.#mainSources.advance(expectedHead, newHead, changes);
       } finally {
         this.#endTransaction();
       }
@@ -13819,7 +13875,11 @@ var ZeroContext = class {
   }
   #endTransaction() {
     for (const listener of this.#commitListeners) {
-      listener();
+      try {
+        listener();
+      } catch (e) {
+        this.lc.error?.("Failed notifying a commit listener of IVM updates", e);
+      }
     }
   }
 };
@@ -13993,7 +14053,7 @@ async function upsertImpl(tx, arg, schema, ivmBranch) {
   await tx.set(key, val);
   if (ivmBranch) {
     must(ivmBranch.getSource(arg.tableName)).push({
-      type: "add",
+      type: "set",
       row: arg.value
     });
   }
@@ -14045,7 +14105,7 @@ async function deleteImpl(tx, arg, schema, ivmBranch) {
 
 // ../zero-client/src/client/custom.ts
 var TransactionImpl = class {
-  constructor(repTx, schema) {
+  constructor(lc, repTx, schema, slowMaterializeThreshold) {
     const castedRepTx = repTx;
     must(repTx.reason === "initial" || repTx.reason === "rebase");
     this.clientID = repTx.clientID;
@@ -14054,9 +14114,25 @@ var TransactionImpl = class {
     this.mutate = makeSchemaCRUD(
       schema,
       repTx,
-      castedRepTx[zeroData]
+      // CRUD operators should not mutate the IVM store directly
+      // for `initial`. The IVM store will be updated via calls to `advance`
+      // after the transaction has been committed to the Replicache b-tree.
+      // Mutating the IVM store in the mutator would cause us to synchronously
+      // notify listeners of IVM while we're inside of the Replicache DB transaction.
+      repTx.reason === "initial" ? void 0 : must(
+        castedRepTx[zeroData],
+        "zero was not set on replicache internal options!"
+      )
+    );
+    this.query = makeSchemaQuery(
+      lc,
+      schema,
+      must(
+        castedRepTx[zeroData],
+        "zero was not set on replicache internal options!"
+      ),
+      slowMaterializeThreshold
     );
-    this.query = {};
   }
   clientID;
   mutationID;
@@ -14065,18 +14141,49 @@ var TransactionImpl = class {
   mutate;
   query;
 };
-function makeReplicacheMutator(mutator, schema) {
+function makeReplicacheMutator(lc, mutator, schema, slowMaterializeThreshold) {
   return (repTx, args) => {
-    const tx = new TransactionImpl(repTx, schema);
+    const tx = new TransactionImpl(lc, repTx, schema, slowMaterializeThreshold);
     return mutator(tx, args);
   };
 }
 function makeSchemaCRUD(schema, tx, ivmBranch) {
-  const mutate = {};
-  for (const [name] of Object.entries(schema.tables)) {
-    mutate[name] = makeTableCRUD(schema, name, tx, ivmBranch);
-  }
-  return mutate;
+  return new Proxy(
+    {},
+    {
+      get(target, prop) {
+        if (prop in target) {
+          return target[prop];
+        }
+        target[prop] = makeTableCRUD(schema, prop, tx, ivmBranch);
+        return target[prop];
+      }
+    }
+  );
+}
+function makeSchemaQuery(lc, schema, ivmBranch, slowMaterializeThreshold) {
+  const context = new ZeroContext(
+    lc,
+    ivmBranch,
+    () => () => {
+    },
+    () => {
+    },
+    (applyViewUpdates) => applyViewUpdates(),
+    slowMaterializeThreshold
+  );
+  return new Proxy(
+    {},
+    {
+      get(target, prop) {
+        if (prop in target) {
+          return target[prop];
+        }
+        target[prop] = newQuery(context, schema, prop);
+        return target[prop];
+      }
+    }
+  );
 }
 function makeTableCRUD(schema, tableName, tx, ivmBranch) {
   const table2 = must(schema.tables[tableName]);
@@ -14408,7 +14515,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.17.2025031200";
+var version2 = "0.17.2025031300";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14819,22 +14926,7 @@ var QueryManager = class {
       ]);
     } else {
       ++entry.count;
-      if (compareTTL(ttl, entry.ttl) > 0) {
-        entry.ttl = ttl;
-        this.#send([
-          "changeDesiredQueries",
-          {
-            desiredQueriesPatch: [
-              {
-                op: "put",
-                hash: astHash,
-                ast: entry.normalized,
-                ttl: parseTTL(ttl)
-              }
-            ]
-          }
-        ]);
-      }
+      this.#updateEntry(entry, astHash, ttl);
       if (gotCallback) {
         entry.gotCallbacks.push(gotCallback);
       }
@@ -14851,6 +14943,30 @@ var QueryManager = class {
       this.#remove(entry, astHash, gotCallback);
     };
   }
+  update(ast, ttl) {
+    const normalized = normalizeAST(ast);
+    const astHash = hashOfAST(normalized);
+    const entry = must(this.#queries.get(astHash));
+    this.#updateEntry(entry, astHash, ttl);
+  }
+  #updateEntry(entry, hash2, ttl) {
+    if (compareTTL(ttl, entry.ttl) > 0) {
+      entry.ttl = ttl;
+      this.#send([
+        "changeDesiredQueries",
+        {
+          desiredQueriesPatch: [
+            {
+              op: "put",
+              hash: hash2,
+              ast: entry.normalized,
+              ttl: parseTTL(ttl)
+            }
+          ]
+        }
+      ]);
+    }
+  }
   #remove(entry, astHash, gotCallback) {
     if (gotCallback) {
       const index = entry.gotCallbacks.indexOf(gotCallback);
@@ -15322,6 +15438,51 @@ function rafFallback(callback) {
   setTimeout(callback, 0);
 }
 
+// ../zero-client/src/client/zero-rep.ts
+var ZeroRep = class {
+  #context;
+  #ivmMain;
+  #customMutatorsEnabled;
+  #store;
+  constructor(context, ivmMain, customMutatorsEnabled) {
+    this.#context = context;
+    this.#ivmMain = ivmMain;
+    this.#customMutatorsEnabled = customMutatorsEnabled;
+  }
+  async init(hash2, store) {
+    const diffs = [];
+    await withRead(store, async (dagRead) => {
+      const read = await readFromHash(hash2, dagRead, Latest);
+      for await (const entry of read.map.scan(ENTITIES_KEY_PREFIX)) {
+        if (!entry[0].startsWith(ENTITIES_KEY_PREFIX)) {
+          break;
+        }
+        diffs.push({
+          op: "add",
+          key: entry[0],
+          newValue: entry[1]
+        });
+      }
+    });
+    this.#store = store;
+    this.#context.processChanges(void 0, hash2, diffs);
+  }
+  getTxData = (reason, desiredHead, readOptions) => {
+    if (!this.#customMutatorsEnabled) {
+      return;
+    }
+    return this.#ivmMain.forkToHead(
+      reason,
+      must(this.#store),
+      desiredHead,
+      readOptions
+    );
+  };
+  advance = (expectedHash, newHash, diffs) => {
+    this.#context.processChanges(expectedHash, newHash, diffs);
+  };
+};
+
 // ../zero-client/src/client/zero.ts
 var onSetConnectionStateSymbol = Symbol();
 var exposedToTestingSymbol = Symbol();
@@ -15512,13 +15673,19 @@ var Zero = class {
       [CRUD_MUTATION_NAME]: makeCRUDMutator(schema)
     };
     this.#ivmMain = new IVMSourceBranch(schema.tables);
+    const lc = new LogContext4(logOptions.logLevel, {}, logOptions.logSink);
     for (const [namespace, mutatorsForNamespace] of Object.entries(
       options.mutators ?? {}
     )) {
       for (const [name, mutator] of Object.entries(
         mutatorsForNamespace
       )) {
-        replicacheMutators[customMutatorKey(namespace, name)] = makeReplicacheMutator(mutator, schema);
+        replicacheMutators[customMutatorKey(namespace, name)] = makeReplicacheMutator(
+          lc,
+          mutator,
+          schema,
+          slowMaterializeThreshold
+        );
       }
     }
     this.storageKey = storageKey ?? "";
@@ -15542,10 +15709,23 @@ var Zero = class {
       licenseKey: "zero-client-static-key",
       kvStore
     };
+    this.#zeroContext = new ZeroContext(
+      lc,
+      this.#ivmMain,
+      (ast, ttl, gotCallback) => this.#queryManager.add(ast, ttl, gotCallback),
+      (ast, ttl) => this.#queryManager.update(ast, ttl),
+      batchViewUpdates,
+      slowMaterializeThreshold
+    );
     const replicacheImplOptions = {
       enableClientGroupForking: false,
       enableMutationRecovery: false,
-      onClientsDeleted: (clientIDs, clientGroupIDs) => this.#deleteClientsManager.onClientsDeleted(clientIDs, clientGroupIDs)
+      onClientsDeleted: (clientIDs, clientGroupIDs) => this.#deleteClientsManager.onClientsDeleted(clientIDs, clientGroupIDs),
+      zero: new ZeroRep(
+        this.#zeroContext,
+        this.#ivmMain,
+        options.mutators !== void 0
+      )
     };
     const rep = new ReplicacheImpl(replicacheOptions, replicacheImplOptions);
     this.#rep = rep;
@@ -15554,11 +15734,7 @@ var Zero = class {
     }
     this.#server = server;
     this.userID = userID;
-    this.#lc = new LogContext4(
-      logOptions.logLevel,
-      { clientID: rep.clientID },
-      logOptions.logSink
-    );
+    this.#lc = lc.withContext("clientID", rep.clientID);
     const onUpdateNeededCallback = onUpdateNeeded ?? ((reason, serverErrorMsg) => {
       reloadWithReason(
         this.#lc,
@@ -15613,20 +15789,6 @@ var Zero = class {
       rep.perdag,
       this.#lc
     );
-    this.#zeroContext = new ZeroContext(
-      this.#lc,
-      this.#ivmMain,
-      (ast, ttl, gotCallback) => this.#queryManager.add(ast, ttl, gotCallback),
-      batchViewUpdates,
-      slowMaterializeThreshold
-    );
-    rep.experimentalWatch(
-      (diff3) => this.#zeroContext.processChanges(diff3),
-      {
-        prefix: ENTITIES_KEY_PREFIX,
-        initialValuesInFirstDiff: true
-      }
-    );
     this.query = this.#registerQueries(schema);
     reportReloadReason(this.#lc);
     this.#metrics = new MetricManager({
@@ -16629,4 +16791,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-VNV6U5BQ.js.map
+//# sourceMappingURL=chunk-APXCO5Z2.js.map