@rocicorp/zero 0.17.2025030300 → 0.17.2025030601

package/out/{chunk-BBNRRMOA.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:
@@ -11053,13 +11025,16 @@ function unwrap(c) {
   return { type: c.type, conditions: flatten(c.type, c.conditions.map(unwrap)) };
 }
 
+// ../zql/src/query/query.ts
+var DEFAULT_TTL = 1e4;
+
 // ../zql/src/query/query-impl.ts
 var astForTestingSymbol = Symbol();
 function newQuery(delegate, schema, table2) {
   return new QueryImpl(delegate, schema, table2);
 }
-function newQueryWithDetails(delegate, schema, tableName, ast, ttl, format) {
-  return new QueryImpl(delegate, schema, tableName, ast, ttl, format);
+function newQueryWithDetails(delegate, schema, tableName, ast, format) {
+  return new QueryImpl(delegate, schema, tableName, ast, format);
 }
 function staticParam(anchorClass, field) {
   return {
@@ -11074,14 +11049,12 @@ var AbstractQuery = class {
   #schema;
   #tableName;
   #ast;
-  #ttl;
   #format;
   #hash = "";
-  constructor(schema, tableName, ast = { table: tableName }, ttl, format) {
+  constructor(schema, tableName, ast = { table: tableName }, format) {
     this.#schema = schema;
     this.#tableName = tableName;
     this.#ast = ast;
-    this.#ttl = ttl;
     this.#format = format ?? { singular: false, relationships: {} };
   }
   get format() {
@@ -11107,7 +11080,6 @@ var AbstractQuery = class {
         ...this.#ast,
         limit: 1
       },
-      this.#ttl,
       {
         ...this.#format,
         singular: true
@@ -11136,7 +11108,6 @@ var AbstractQuery = class {
             table: destSchema,
             alias: relationship
           },
-          this.#ttl,
           {
             relationships: {},
             singular: cardinality === "one"
@@ -11175,7 +11146,6 @@ var AbstractQuery = class {
             }
           ]
         },
-        this.#ttl,
         {
           ...this.#format,
           relationships: {
@@ -11198,7 +11168,6 @@ var AbstractQuery = class {
             table: destSchema,
             alias: relationship
           },
-          this.#ttl,
           {
             relationships: {},
             singular: secondRelation.cardinality === "one"
@@ -11247,7 +11216,6 @@ var AbstractQuery = class {
             }
           ]
         },
-        this.#ttl,
         {
           ...this.#format,
           relationships: {
@@ -11280,7 +11248,6 @@ var AbstractQuery = class {
         ...this.#ast,
         where: dnf(cond)
       },
-      this.#ttl,
       this.#format
     );
   }
@@ -11295,7 +11262,6 @@ var AbstractQuery = class {
           exclusive: !opts?.inclusive
         }
       },
-      this.#ttl,
       this.#format
     );
   }
@@ -11313,7 +11279,6 @@ var AbstractQuery = class {
         ...this.#ast,
         limit
       },
-      this.#ttl,
       this.#format
     );
   }
@@ -11325,7 +11290,6 @@ var AbstractQuery = class {
         ...this.#ast,
         orderBy: [...this.#ast.orderBy ?? [], [field, direction]]
       },
-      this.#ttl,
       this.#format
     );
   }
@@ -11344,7 +11308,6 @@ var AbstractQuery = class {
             table: destSchema,
             alias: `${SUBQ_PREFIX}${relationship}`
           },
-          this.#ttl,
           void 0
         )
       );
@@ -11381,7 +11344,6 @@ var AbstractQuery = class {
             table: destSchema,
             alias: `${SUBQ_PREFIX}${relationship}`
           },
-          this.#ttl,
           void 0
         )
       );
@@ -11459,29 +11421,27 @@ var AbstractQuery = class {
 var completedAstSymbol = Symbol();
 var QueryImpl = class extends AbstractQuery {
   #delegate;
-  constructor(delegate, schema, tableName, ast, ttl, format) {
-    super(schema, tableName, ast, ttl, format);
+  constructor(delegate, schema, tableName, ast, format) {
+    super(schema, tableName, ast, format);
     this.#delegate = delegate;
   }
   _system = "client";
   get [completedAstSymbol]() {
     return this._completeAst();
   }
-  _newQuery(schema, tableName, ast, ttl, format) {
-    return newQueryWithDetails(
-      this.#delegate,
-      schema,
-      tableName,
-      ast,
-      ttl,
-      format
-    );
+  _newQuery(schema, tableName, ast, format) {
+    return newQueryWithDetails(this.#delegate, schema, tableName, ast, format);
   }
-  materialize(factory) {
+  materialize(factoryOrTTL, ttl = DEFAULT_TTL) {
+    let factory;
+    if (typeof factoryOrTTL === "function") {
+      factory = factoryOrTTL;
+    } else {
+      ttl = factoryOrTTL ?? DEFAULT_TTL;
+    }
     const ast = this._completeAst();
     const queryCompleteResolver = resolver7();
     let queryGot = false;
-    const ttl = void 0;
     const removeServerQuery = this.#delegate.addServerQuery(ast, ttl, (got) => {
       if (got) {
         queryGot = true;
@@ -11515,15 +11475,18 @@ var QueryImpl = class extends AbstractQuery {
     v2.destroy();
     return Promise.resolve(ret);
   }
-  preload() {
+  preload(options) {
     const { resolve, promise: complete } = resolver7();
     const ast = this._completeAst();
-    const ttl = void 0;
-    const unsub = this.#delegate.addServerQuery(ast, ttl, (got) => {
-      if (got) {
-        resolve();
+    const unsub = this.#delegate.addServerQuery(
+      ast,
+      options?.ttl ?? DEFAULT_TTL,
+      (got) => {
+        if (got) {
+          resolve();
+        }
       }
-    });
+    );
     return {
       cleanup: unsub,
       complete
@@ -11569,8 +11532,8 @@ var StaticQuery = class _StaticQuery extends AbstractQuery {
     return new ExpressionBuilder(this._exists);
   }
   _system = "permissions";
-  _newQuery(schema, tableName, ast, ttl, format) {
-    return new _StaticQuery(schema, tableName, ast, ttl, format);
+  _newQuery(schema, tableName, ast, format) {
+    return new _StaticQuery(schema, tableName, ast, format);
   }
   get ast() {
     return this._completeAst();
@@ -13274,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)) {
@@ -13382,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,
@@ -13405,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 {
@@ -13453,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 {
@@ -13722,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;
@@ -13747,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 {
@@ -13781,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
     )
   };
 }
@@ -14103,7 +14038,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.17.2025030300";
+var version2 = "0.17.2025030601";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14416,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":
@@ -15056,6 +14991,7 @@ function onClientStateNotFoundServerReason(serverErrMsg) {
   return `Server could not find state needed to synchronize this client. ${serverErrMsg}`;
 }
 var ON_CLIENT_STATE_NOT_FOUND_REASON_CLIENT = "The local persistent state needed to synchronize this client has been garbage collected.";
+var CLOSE_CODE_NORMAL = 1e3;
 var Zero = class {
   version = version2;
   #rep;
@@ -15067,7 +15003,7 @@ var Zero = class {
   #enableAnalytics;
   #pokeHandler;
   #queryManager;
-  #ivmSources;
+  #ivmMain;
   #clientToServer;
   #deleteClientsManager;
   /**
@@ -15199,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 ?? "";
@@ -15300,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
@@ -15322,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,
@@ -15449,16 +15385,39 @@ var Zero = class {
    */
   close() {
     const lc = this.#lc.withContext("close");
+    lc.debug?.("Closing Zero instance. Stack:", new Error().stack);
     if (this.#connectionState !== Disconnected) {
-      this.#disconnect(lc, {
-        client: "ClientClosed"
-      });
+      let closeReason = JSON.stringify([
+        "closeConnection",
+        []
+      ]);
+      if (closeReason.length > 123) {
+        lc.warn?.("Close reason is too long. Removing it.");
+        closeReason = "";
+      }
+      this.#disconnect(
+        lc,
+        {
+          client: "ClientClosed"
+        },
+        CLOSE_CODE_NORMAL,
+        closeReason
+      );
     }
     lc.debug?.("Aborting closeAbortController due to close()");
     this.#closeAbortController.abort();
     this.#metrics.stop();
     return this.#rep.close();
   }
+  #onPageHide = (e) => {
+    if (e.persisted) {
+      this.#lc.debug?.("Ignoring pagehide event because it was persisted");
+    } else {
+      this.#lc.debug?.("Closing client because we got a clean close");
+      this.close().catch(() => {
+      });
+    }
+  };
   #onMessage = (e) => {
     const lc = this.#lc;
     lc.debug?.("received message", e.data);
@@ -15716,6 +15675,7 @@ var Zero = class {
     ws.addEventListener("close", this.#onClose);
     this.#socket = ws;
     this.#socketResolver.resolve(ws);
+    getBrowserGlobal("window")?.addEventListener("pagehide", this.#onPageHide);
     try {
       l.debug?.("Waiting for connection to be acknowledged");
       await this.#connectResolver.promise;
@@ -15727,7 +15687,7 @@ var Zero = class {
       );
     }
   }
-  #disconnect(l, reason) {
+  #disconnect(l, reason, closeCode, closeReason) {
     if (this.#connectionState === Connecting) {
       this.#connectErrorCount++;
     }
@@ -15781,10 +15741,14 @@ var Zero = class {
     this.#socket?.removeEventListener("message", this.#onMessage);
     this.#socket?.removeEventListener("open", this.#onOpen);
     this.#socket?.removeEventListener("close", this.#onClose);
-    this.#socket?.close();
+    this.#socket?.close(closeCode, closeReason);
     this.#socket = void 0;
     this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
     this.#pokeHandler.handleDisconnect();
+    getBrowserGlobal("window")?.removeEventListener(
+      "pagehide",
+      this.#onPageHide
+    );
   }
   #handlePokeStart(_lc, pokeMessage) {
     resetBackoff();
@@ -16278,4 +16242,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-BBNRRMOA.js.map
+//# sourceMappingURL=chunk-EENFDWT4.js.map