@rocicorp/zero 0.17.2025031100 → 0.17.2025031300

package/out/{chunk-2TJNN7K4.js → chunk-APXCO5Z2.js}

@@ -1,7 +1,9 @@
 import {
   DEFAULT_TTL,
-  hasOwn
-} from "./chunk-HLTH2AYN.js";
+  compareTTL,
+  hasOwn,
+  parseTTL
+} from "./chunk-5X3DESC6.js";
 import {
   applyChange,
   assert,
@@ -19,7 +21,7 @@ import {
   throwInvalidType,
   unreachable,
   valuesEqual
-} from "./chunk-6CQ6CUML.js";
+} from "./chunk-7ARRNDLF.js";
 import {
   __export,
   __reExport
@@ -2227,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,
@@ -2235,7 +2237,8 @@ var LazyStore = class {
       this._sourceChunksCache,
       this.#sourceStore,
       release,
-      this.#assertValidHash
+      this.#assertValidHash,
+      sourceRead
     );
   }
   async write() {
@@ -2274,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);
@@ -2311,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;
     }
   }
@@ -3844,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);
@@ -4561,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();
@@ -5323,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
@@ -5359,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,
@@ -5389,6 +5404,8 @@ function maybeEndPull(store, lc, expectedSyncHead, clientID, diffConfig, formatV
     }
     return {
       syncHead: syncHeadHash,
+      oldMainHead: mainHeadHash,
+      mainHead: newMainHeadHash,
       replayMutations: [],
       diffs: diffsMap
     };
@@ -6234,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;
   }
@@ -6298,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;
@@ -6343,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,
@@ -6354,7 +6379,8 @@ async function persistDD31(lc, clientID, memdag, perdag, mutators, closed, forma
       mutators,
       mutationIDs,
       lc,
-      formatVersion
+      formatVersion,
+      zeroDataForPerdagHeadCommit ?? zeroDataForMemdagBaseSnapshot
     );
     const newMainClientGroup = {
       ...mainClientGroup,
@@ -6376,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;
@@ -6391,7 +6417,7 @@ async function rebase(mutations, basis, write, mutators, mutationIDs, lc, format
         lc,
         meta.clientID,
         formatVersion,
-        void 0
+        zeroData2
       )).chunk.hash;
     }
   }
@@ -6433,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;
   }
@@ -6548,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,
@@ -6575,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
       };
     });
@@ -6596,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(
@@ -7185,6 +7227,7 @@ var ReplicacheImpl = class {
   perdag;
   #idbDatabases;
   #lc;
+  #zero;
   #closeAbortController = new AbortController();
   #persistLock = new Lock2();
   #enableScheduledPersist;
@@ -7294,6 +7337,7 @@ var ReplicacheImpl = class {
       onClientsDeleted = () => {
       }
     } = implOptions;
+    this.#zero = implOptions.zero;
     this.auth = auth ?? "";
     this.pullURL = pullURL;
     this.pushURL = pushURL;
@@ -7399,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);
@@ -7565,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,
@@ -7574,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();
@@ -7594,7 +7641,7 @@ var ReplicacheImpl = class {
             lc,
             isLocalMetaDD31(meta) ? meta.clientID : clientID,
             Latest,
-            void 0
+            zeroData2
           )
         );
       }
@@ -7906,7 +7953,8 @@ var ReplicacheImpl = class {
           this.perdag,
           this.#mutatorRegistry,
           () => this.#closed,
-          Latest
+          Latest,
+          this.#zero?.getTxData
         );
       } catch (e) {
         if (e instanceof ClientStateNotFoundError) {
@@ -7928,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,
@@ -7938,7 +7986,8 @@ var ReplicacheImpl = class {
         this.#mutatorRegistry,
         this.#subscriptions,
         () => this.closed,
-        Latest
+        Latest,
+        this.#zero
       );
     } catch (e) {
       if (e instanceof ClientStateNotFoundError) {
@@ -7949,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() {
@@ -8141,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();
@@ -9219,9 +9271,7 @@ var Exists = class {
             case "remove": {
               let size = this.#getSize(change.node);
               if (size !== void 0) {
-                if (size === 0) {
-                  return;
-                }
+                assert(size > 0);
                 size--;
                 this.#setSize(change.node, size);
               } else {
@@ -9617,6 +9667,7 @@ var Join = class {
   #relationshipName;
   #schema;
   #output = throwOutput;
+  #inprogressChildChange;
   constructor({
     parent,
     child,
@@ -9749,25 +9800,34 @@ var Join = class {
   }
   #pushChild(change) {
     const pushChildChange = (childRow, change2) => {
-      const parentNodes = this.#parent.fetch({
-        constraint: Object.fromEntries(
-          this.#parentKey.map((key, i) => [key, childRow[this.#childKey[i]]])
-        )
-      });
-      for (const parentNode of parentNodes) {
-        const childChange = {
-          type: "child",
-          node: this.#processParentNode(
-            parentNode.row,
-            parentNode.relationships,
-            "fetch"
-          ),
-          child: {
-            relationshipName: this.#relationshipName,
-            change: change2
-          }
-        };
-        this.#output.push(childChange);
+      this.#inprogressChildChange = {
+        change: change2,
+        position: void 0
+      };
+      try {
+        const parentNodes = this.#parent.fetch({
+          constraint: Object.fromEntries(
+            this.#parentKey.map((key, i) => [key, childRow[this.#childKey[i]]])
+          )
+        });
+        for (const parentNode of parentNodes) {
+          this.#inprogressChildChange.position = parentNode.row;
+          const childChange = {
+            type: "child",
+            node: this.#processParentNode(
+              parentNode.row,
+              parentNode.relationships,
+              "fetch"
+            ),
+            child: {
+              relationshipName: this.#relationshipName,
+              change: change2
+            }
+          };
+          this.#output.push(childChange);
+        }
+      } finally {
+        this.#inprogressChildChange = void 0;
       }
     };
     switch (change.type) {
@@ -9792,6 +9852,81 @@ var Join = class {
         unreachable(change);
     }
   }
+  *#generateChildStreamWithOverlay(stream, overlay) {
+    let applied = false;
+    let editOldApplied = false;
+    let editNewApplied = false;
+    for (const child of stream) {
+      let yieldChild = true;
+      if (!applied) {
+        switch (overlay.type) {
+          case "add": {
+            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) === 0) {
+              applied = true;
+              yieldChild = false;
+            }
+            break;
+          }
+          case "remove": {
+            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) < 0) {
+              applied = true;
+              yield overlay.node;
+            }
+            break;
+          }
+          case "edit": {
+            if (this.#child.getSchema().compareRows(overlay.oldNode.row, child.row) < 0) {
+              editOldApplied = true;
+              if (editNewApplied) {
+                applied = true;
+              }
+              yield overlay.oldNode;
+            }
+            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) === 0) {
+              editNewApplied = true;
+              if (editOldApplied) {
+                applied = true;
+              }
+              yieldChild = false;
+            }
+            break;
+          }
+          case "child": {
+            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) === 0) {
+              applied = true;
+              yield {
+                row: child.row,
+                relationships: {
+                  ...child.relationships,
+                  [overlay.child.relationshipName]: () => this.#generateChildStreamWithOverlay(
+                    child.relationships[overlay.child.relationshipName](),
+                    overlay.child.change
+                  )
+                }
+              };
+              yieldChild = false;
+            }
+            break;
+          }
+        }
+      }
+      if (yieldChild) {
+        yield child;
+      }
+    }
+    if (!applied) {
+      if (overlay.type === "remove") {
+        applied = true;
+        yield overlay.node;
+      } else if (overlay.type === "edit") {
+        assert(editNewApplied);
+        editOldApplied = true;
+        applied = true;
+        yield overlay.oldNode;
+      }
+    }
+    assert(applied);
+  }
   #processParentNode(parentNodeRow, parentNodeRelations, mode) {
     let method = mode;
     let storageUpdated = false;
@@ -9827,7 +9962,7 @@ var Join = class {
           );
         }
       }
-      return this.#child[method]({
+      const stream = this.#child[method]({
         constraint: Object.fromEntries(
           this.#childKey.map((key, i) => [
             key,
@@ -9835,6 +9970,19 @@ var Join = class {
           ])
         )
       });
+      if (this.#inprogressChildChange && this.#isJoinMatch(
+        parentNodeRow,
+        this.#inprogressChildChange.change.node.row
+      ) && this.#inprogressChildChange.position && this.#schema.compareRows(
+        parentNodeRow,
+        this.#inprogressChildChange.position
+      ) > 0) {
+        return this.#generateChildStreamWithOverlay(
+          stream,
+          this.#inprogressChildChange.change
+        );
+      }
+      return stream;
     };
     return {
       row: parentNodeRow,
@@ -9844,6 +9992,14 @@ var Join = class {
       }
     };
   }
+  #isJoinMatch(parent, child) {
+    for (let i = 0; i < this.#parentKey.length; i++) {
+      if (!valuesEqual(parent[this.#parentKey[i]], child[this.#childKey[i]])) {
+        return false;
+      }
+    }
+    return true;
+  }
 };
 function makeStorageKeyForValues(values) {
   const json2 = JSON.stringify(["pKeySet", ...values]);
@@ -10153,6 +10309,7 @@ var Take = class {
         type: "remove",
         node: boundNode
       };
+      this.#output.push(change);
       this.#setTakeState(
         takeStateKey,
         takeState.size,
@@ -10160,7 +10317,6 @@ var Take = class {
         maxBound
       );
       this.#output.push(removeChange);
-      this.#output.push(change);
     } else if (change.type === "remove") {
       if (takeState.bound === void 0) {
         return;
@@ -10207,13 +10363,13 @@ var Take = class {
         }
       }
       if (newBound?.push) {
+        this.#output.push(change);
         this.#setTakeState(
           takeStateKey,
           takeState.size,
           newBound.node.row,
           maxBound
         );
-        this.#output.push(change);
         this.#output.push({
           type: "add",
           node: newBound.node
@@ -10308,10 +10464,6 @@ var Take = class {
         newBoundNode.row,
         maxBound
       );
-      this.#output.push({
-        type: "remove",
-        node: change.oldNode
-      });
       this.#output.push({
         type: "add",
         node: newBoundNode
@@ -10335,6 +10487,10 @@ var Take = class {
         }),
         2
       );
+      this.#output.push({
+        type: "add",
+        node: change.node
+      });
       this.#setTakeState(
         takeStateKey,
         takeState.size,
@@ -10345,10 +10501,6 @@ var Take = class {
         type: "remove",
         node: oldBoundNode
       });
-      this.#output.push({
-        type: "add",
-        node: change.node
-      });
       return;
     }
     if (oldCmp < 0) {
@@ -10373,16 +10525,16 @@ var Take = class {
         replaceBoundAndForwardChange();
         return;
       }
+      this.#output.push({
+        type: "remove",
+        node: change.oldNode
+      });
       this.#setTakeState(
         takeStateKey,
         takeState.size,
         afterBoundNode.row,
         maxBound
       );
-      this.#output.push({
-        type: "remove",
-        node: change.oldNode
-      });
       this.#output.push({
         type: "add",
         node: afterBoundNode
@@ -11649,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;
@@ -11727,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
@@ -11992,40 +12150,6 @@ function escapeLike(val) {
   return val.replace(/[%_]/g, "\\$&");
 }
 
-// ../zql/src/query/ttl.ts
-var DEFAULT_TTL2 = "none";
-var multiplier = {
-  s: 1e3,
-  m: 60 * 1e3,
-  h: 60 * 60 * 1e3,
-  d: 24 * 60 * 60 * 1e3,
-  y: 365 * 24 * 60 * 60 * 1e3
-};
-function parseTTL(ttl) {
-  if (typeof ttl === "number") {
-    return Number.isNaN(ttl) ? 0 : !Number.isFinite(ttl) || ttl < 0 ? -1 : ttl;
-  }
-  if (ttl === "none") {
-    return 0;
-  }
-  if (ttl === "forever") {
-    return -1;
-  }
-  const multi = multiplier[ttl[ttl.length - 1]];
-  return Number(ttl.slice(0, -1)) * multi;
-}
-function compareTTL(a, b) {
-  const ap = parseTTL(a);
-  const bp = parseTTL(b);
-  if (ap === -1 && bp !== -1) {
-    return 1;
-  }
-  if (ap !== -1 && bp === -1) {
-    return -1;
-  }
-  return ap - bp;
-}
-
 // ../zero-client/src/client/zero.ts
 import { LogContext as LogContext4 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
@@ -13188,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,
@@ -13547,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;
   }
@@ -13581,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,
@@ -13601,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) {
@@ -13645,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;
@@ -13663,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?.(
@@ -13705,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();
       }
@@ -13751,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);
+      }
     }
   }
 };
@@ -13925,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
     });
   }
@@ -13977,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;
@@ -13986,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;
@@ -13997,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]);
@@ -14340,7 +14515,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.17.2025031100";
+var version2 = "0.17.2025031300";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14751,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);
       }
@@ -14783,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);
@@ -15254,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();
@@ -15444,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 ?? "";
@@ -15474,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;
@@ -15486,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,
@@ -15545,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({
@@ -16559,7 +16789,6 @@ export {
   NOBODY_CAN,
   definePermissions,
   escapeLike,
-  DEFAULT_TTL2 as DEFAULT_TTL,
   Zero
 };
-//# sourceMappingURL=chunk-2TJNN7K4.js.map
+//# sourceMappingURL=chunk-APXCO5Z2.js.map