@rocicorp/zero 0.17.2025030701 → 0.17.2025031200

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

@@ -1,6 +1,9 @@
 import {
-  hasOwn
-} from "./chunk-HARIWJ2J.js";
+  DEFAULT_TTL,
+  compareTTL,
+  hasOwn,
+  parseTTL
+} from "./chunk-2Y24MEEQ.js";
 import {
   applyChange,
   assert,
@@ -18,7 +21,7 @@ import {
   throwInvalidType,
   unreachable,
   valuesEqual
-} from "./chunk-6XQK3UTJ.js";
+} from "./chunk-6CQ6CUML.js";
 import {
   __export,
   __reExport
@@ -8457,6 +8460,65 @@ function one(...args) {
   }));
 }
 
+// ../shared/src/hash.ts
+import { xxHash32 } from "js-xxhash";
+var h64 = (s) => hash(s, 2);
+var h128 = (s) => hash(s, 4);
+function hash(str, words) {
+  let hash2 = 0n;
+  for (let i = 0; i < words; i++) {
+    hash2 = (hash2 << 32n) + BigInt(xxHash32(str, i));
+  }
+  return hash2;
+}
+
+// ../shared/src/objects.ts
+function mapEntries(input, mapper) {
+  const output = {};
+  for (const entry of Object.entries(input)) {
+    const mapped = mapper(entry[0], entry[1]);
+    output[mapped[0]] = mapped[1];
+  }
+  return output;
+}
+function mapAllEntries(input, mapper) {
+  const output = {};
+  for (const mapped of mapper(Object.entries(input))) {
+    output[mapped[0]] = mapped[1];
+  }
+  return output;
+}
+
+// ../zero-protocol/src/client-schema.ts
+var valueTypeSchema = valita_exports.union(
+  valita_exports.literal("string"),
+  valita_exports.literal("number"),
+  valita_exports.literal("boolean"),
+  valita_exports.literal("null"),
+  valita_exports.literal("json")
+);
+var columnSchemaSchema = valita_exports.object({
+  type: valueTypeSchema
+});
+var tableSchemaSchema = valita_exports.object({
+  columns: valita_exports.record(columnSchemaSchema)
+});
+var clientSchemaSchema = valita_exports.object({
+  tables: valita_exports.record(tableSchemaSchema)
+});
+var keyCmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
+function normalizeClientSchema(schema) {
+  return {
+    tables: mapAllEntries(
+      schema.tables,
+      (tables) => tables.sort(keyCmp).map(([name, table2]) => [
+        name,
+        { columns: mapAllEntries(table2.columns, (e) => e.sort(keyCmp)) }
+      ])
+    )
+  };
+}
+
 // ../zero-schema/src/builder/table-builder.ts
 function table(name) {
   return new TableBuilder({
@@ -8575,7 +8637,7 @@ var ColumnBuilder = class _ColumnBuilder {
 };
 
 // ../zero-schema/src/builder/schema-builder.ts
-function createSchema(version3, options) {
+function createSchema(options) {
   const retTables = {};
   const retRelationships = {};
   const serverNames = /* @__PURE__ */ new Set();
@@ -8606,7 +8668,6 @@ function createSchema(version3, options) {
     );
   });
   return {
-    version: version3,
     tables: retTables,
     relationships: retRelationships
   };
@@ -8629,6 +8690,22 @@ function checkRelationship(relationships2, tableName, tables) {
     });
   });
 }
+function clientSchemaFrom(schema) {
+  const client = {
+    tables: mapEntries(schema.tables, (name, { serverName, columns }) => [
+      serverName ?? name,
+      {
+        columns: mapEntries(columns, (name2, { serverName: serverName2, type }) => [
+          serverName2 ?? name2,
+          { type }
+        ])
+      }
+    ])
+  };
+  const clientSchema2 = normalizeClientSchema(client);
+  const hash2 = h64(JSON.stringify(clientSchema2)).toString(36);
+  return { clientSchema: clientSchema2, hash: hash2 };
+}
 
 // ../zero-protocol/src/ast.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
@@ -8976,18 +9053,6 @@ function compareUTF8MaybeNull(a, b) {
 // ../zql/src/query/query-impl.ts
 import { resolver as resolver7 } from "@rocicorp/resolver";
 
-// ../shared/src/hash.ts
-import { xxHash32 } from "js-xxhash";
-var h64 = (s) => hash(s, 2);
-var h128 = (s) => hash(s, 4);
-function hash(str, words) {
-  let hash2 = 0n;
-  for (let i = 0; i < words; i++) {
-    hash2 = (hash2 << 32n) + BigInt(xxHash32(str, i));
-  }
-  return hash2;
-}
-
 // ../zero-protocol/src/ast-hash.ts
 var hashCache = /* @__PURE__ */ new WeakMap();
 function hashOfAST(ast) {
@@ -9059,7 +9124,10 @@ var Exists = class {
     this.#relationshipName = relationshipName;
     this.#input.setOutput(this);
     this.#storage = storage;
-    assert(this.#input.getSchema().relationships[relationshipName]);
+    assert(
+      this.#input.getSchema().relationships[relationshipName],
+      `Input schema missing ${relationshipName}`
+    );
     this.#not = type === "NOT EXISTS";
     this.#parentJoinKey = parentJoinKey;
     this.#noSizeReuse = areEqual(
@@ -9153,9 +9221,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 {
@@ -9273,17 +9339,17 @@ var Exists = class {
 // ../zql/src/ivm/fan-in.ts
 var FanIn = class {
   #inputs;
-  #fanOut;
   #schema;
   #output = throwOutput;
+  #accumulatedPushes;
   constructor(fanOut, inputs) {
     this.#inputs = inputs;
     this.#schema = fanOut.getSchema();
-    this.#fanOut = fanOut;
     for (const input of inputs) {
       input.setOutput(this);
       assert(this.#schema === input.getSchema(), `Schema mismatch in fan-in`);
     }
+    this.#accumulatedPushes = [];
   }
   setOutput(output) {
     this.#output = output;
@@ -9311,8 +9377,102 @@ var FanIn = class {
     );
   }
   push(change) {
-    this.#fanOut.onFanInReceivedPush();
-    this.#output.push(change);
+    this.#accumulatedPushes.push(change);
+  }
+  fanOutDonePushingToAllBranches(fanOutChangeType) {
+    if (this.#inputs.length === 0) {
+      assert(
+        this.#accumulatedPushes.length === 0,
+        "If there are no inputs then fan-in should not receive any pushes."
+      );
+      return;
+    }
+    if (this.#accumulatedPushes.length === 0) {
+      return;
+    }
+    const candidatesToPush = /* @__PURE__ */ new Map();
+    for (const change of this.#accumulatedPushes) {
+      if (fanOutChangeType === "child" && change.type !== "child") {
+        assert(
+          candidatesToPush.has(change.type) === false,
+          () => `Fan-in:child expected at most one ${change.type} when fan-out is of type child`
+        );
+      }
+      candidatesToPush.set(change.type, change);
+    }
+    this.#accumulatedPushes = [];
+    const types = [...candidatesToPush.keys()];
+    switch (fanOutChangeType) {
+      case "remove":
+        assert(
+          types.length === 1 && types[0] === "remove",
+          "Fan-in:remove expected all removes"
+        );
+        this.#output.push(must(candidatesToPush.get("remove")));
+        return;
+      case "add":
+        assert(
+          types.length === 1 && types[0] === "add",
+          "Fan-in:add expected all adds"
+        );
+        this.#output.push(must(candidatesToPush.get("add")));
+        return;
+      case "edit": {
+        assert(
+          types.every(
+            (type) => type === "add" || type === "remove" || type === "edit"
+          ),
+          "Fan-in:edit expected all adds, removes, or edits"
+        );
+        const addChange = candidatesToPush.get("add");
+        const removeChange = candidatesToPush.get("remove");
+        const editChange = candidatesToPush.get("edit");
+        if (editChange) {
+          this.#output.push(editChange);
+          return;
+        }
+        if (addChange && removeChange) {
+          this.#output.push({
+            type: "edit",
+            node: addChange.node,
+            oldNode: removeChange.node
+          });
+          return;
+        }
+        this.#output.push(must(addChange ?? removeChange));
+        return;
+      }
+      case "child": {
+        assert(
+          types.every(
+            (type) => type === "add" || // exists can change child to add or remove
+            type === "remove" || // exists can change child to add or remove
+            type === "child"
+            // other operators may preserve the child change
+          ),
+          "Fan-in:child expected all adds, removes, or children"
+        );
+        assert(
+          types.length <= 2,
+          "Fan-in:child expected at most 2 types on a child change from fan-out"
+        );
+        const childChange = candidatesToPush.get("child");
+        if (childChange) {
+          this.#output.push(childChange);
+          return;
+        }
+        const addChange = candidatesToPush.get("add");
+        const removeChange = candidatesToPush.get("remove");
+        assert(
+          addChange === void 0 || removeChange === void 0,
+          "Fan-in:child expected either add or remove, not both"
+        );
+        this.#output.push(must(addChange ?? removeChange));
+        return;
+      }
+      default:
+        fanOutChangeType;
+    }
   }
 };
 
@@ -9320,16 +9480,15 @@ var FanIn = class {
 var FanOut = class {
   #input;
   #outputs = [];
-  // FanOut is paired with a FanIn.
-  // Once FanIn has received a push from FanOut along
-  // any branch, FanOut no longer needs to push that value
-  // across the rest of its outputs..
-  #fanInReceivedPush = false;
+  #fanIn;
   #destroyCount = 0;
   constructor(input) {
     this.#input = input;
     input.setOutput(this);
   }
+  setFanIn(fanIn) {
+    this.#fanIn = fanIn;
+  }
   setOutput(output) {
     this.#outputs.push(output);
   }
@@ -9352,17 +9511,14 @@ var FanOut = class {
   cleanup(req) {
     return this.#input.cleanup(req);
   }
-  onFanInReceivedPush() {
-    this.#fanInReceivedPush = true;
-  }
   push(change) {
-    this.#fanInReceivedPush = false;
     for (const out of this.#outputs) {
       out.push(change);
-      if (this.#fanInReceivedPush) {
-        return;
-      }
     }
+    must(
+      this.#fanIn,
+      "fan-out must have a corresponding fan-in set!"
+    ).fanOutDonePushingToAllBranches(change.type);
   }
 };
 
@@ -9461,6 +9617,7 @@ var Join = class {
   #relationshipName;
   #schema;
   #output = throwOutput;
+  #inprogressChildChange;
   constructor({
     parent,
     child,
@@ -9564,34 +9721,27 @@ var Join = class {
         });
         break;
       case "edit": {
-        if (rowEqualsForCompoundKey(
-          change.oldNode.row,
-          change.node.row,
-          this.#parentKey
-        )) {
-          this.#output.push({
-            type: "edit",
-            oldNode: this.#processParentNode(
-              change.oldNode.row,
-              change.oldNode.relationships,
-              "cleanup"
-            ),
-            node: this.#processParentNode(
-              change.node.row,
-              change.node.relationships,
-              "fetch"
-            )
-          });
-        } else {
-          this.#pushParent({
-            type: "remove",
-            node: change.oldNode
-          });
-          this.#pushParent({
-            type: "add",
-            node: change.node
-          });
-        }
+        assert(
+          rowEqualsForCompoundKey(
+            change.oldNode.row,
+            change.node.row,
+            this.#parentKey
+          ),
+          `Parent edit must not change relationship.`
+        );
+        this.#output.push({
+          type: "edit",
+          oldNode: this.#processParentNode(
+            change.oldNode.row,
+            change.oldNode.relationships,
+            "cleanup"
+          ),
+          node: this.#processParentNode(
+            change.node.row,
+            change.node.relationships,
+            "fetch"
+          )
+        });
         break;
       }
       default:
@@ -9600,25 +9750,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) {
@@ -9632,24 +9791,92 @@ var Join = class {
       case "edit": {
         const childRow = change.node.row;
         const oldChildRow = change.oldNode.row;
-        if (rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey)) {
-          pushChildChange(childRow, change);
-        } else {
-          pushChildChange(oldChildRow, {
-            type: "remove",
-            node: change.oldNode
-          });
-          pushChildChange(childRow, {
-            type: "add",
-            node: change.node
-          });
-        }
+        assert(
+          rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey),
+          "Child edit must not change relationship."
+        );
+        pushChildChange(childRow, change);
         break;
       }
       default:
         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;
@@ -9685,7 +9912,7 @@ var Join = class {
           );
         }
       }
-      return this.#child[method]({
+      const stream = this.#child[method]({
         constraint: Object.fromEntries(
           this.#childKey.map((key, i) => [
             key,
@@ -9693,6 +9920,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,
@@ -9702,6 +9942,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]);
@@ -9719,7 +9967,7 @@ function makeStorageKey(key, primaryKey, row) {
 }
 function rowEqualsForCompoundKey(a, b, key) {
   for (let i = 0; i < key.length; i++) {
-    if (!valuesEqual(a[key[i]], b[key[i]])) {
+    if (compareValues(a[key[i]], b[key[i]]) !== 0) {
       return false;
     }
   }
@@ -10011,6 +10259,7 @@ var Take = class {
         type: "remove",
         node: boundNode
       };
+      this.#output.push(change);
       this.#setTakeState(
         takeStateKey,
         takeState.size,
@@ -10018,7 +10267,6 @@ var Take = class {
         maxBound
       );
       this.#output.push(removeChange);
-      this.#output.push(change);
     } else if (change.type === "remove") {
       if (takeState.bound === void 0) {
         return;
@@ -10065,13 +10313,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
@@ -10092,17 +10340,10 @@ var Take = class {
     }
   }
   #pushEditChange(change) {
-    if (this.#partitionKeyComparator && this.#partitionKeyComparator(change.oldNode.row, change.node.row) !== 0) {
-      this.push({
-        type: "remove",
-        node: change.oldNode
-      });
-      this.push({
-        type: "add",
-        node: change.node
-      });
-      return;
-    }
+    assert(
+      !this.#partitionKeyComparator || this.#partitionKeyComparator(change.oldNode.row, change.node.row) === 0,
+      "Unexpected change of partition key"
+    );
     const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.oldNode.row);
     if (!takeState) {
       return;
@@ -10173,10 +10414,6 @@ var Take = class {
         newBoundNode.row,
         maxBound
       );
-      this.#output.push({
-        type: "remove",
-        node: change.oldNode
-      });
       this.#output.push({
         type: "add",
         node: newBoundNode
@@ -10200,6 +10437,10 @@ var Take = class {
         }),
         2
       );
+      this.#output.push({
+        type: "add",
+        node: change.node
+      });
       this.#setTakeState(
         takeStateKey,
         takeState.size,
@@ -10210,10 +10451,6 @@ var Take = class {
         type: "remove",
         node: oldBoundNode
       });
-      this.#output.push({
-        type: "add",
-        node: change.node
-      });
       return;
     }
     if (oldCmp < 0) {
@@ -10238,16 +10475,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
@@ -10521,55 +10758,75 @@ function transformFilters(filters) {
 
 // ../zql/src/builder/builder.ts
 function buildPipeline(ast, delegate) {
-  return buildPipelineInternal(ast, delegate);
+  return buildPipelineInternal(ast, delegate, "");
 }
-function buildPipelineInternal(ast, delegate, partitionKey) {
+function buildPipelineInternal(ast, delegate, name, partitionKey) {
   const source = delegate.getSource(ast.table);
   if (!source) {
     throw new Error(`Source not found: ${ast.table}`);
   }
-  const conn = source.connect(must(ast.orderBy), ast.where);
-  let end = conn;
-  const { fullyAppliedFilters } = conn;
   ast = uniquifyCorrelatedSubqueryConditionAliases(ast);
+  const csqsFromCondition = gatherCorrelatedSubqueryQueriesFromCondition(
+    ast.where
+  );
+  const splitEditKeys = partitionKey ? new Set(partitionKey) : /* @__PURE__ */ new Set();
+  for (const csq of csqsFromCondition) {
+    for (const key of csq.correlation.parentField) {
+      splitEditKeys.add(key);
+    }
+  }
+  if (ast.related) {
+    for (const csq of ast.related) {
+      for (const key of csq.correlation.parentField) {
+        splitEditKeys.add(key);
+      }
+    }
+  }
+  const conn = source.connect(must(ast.orderBy), ast.where, splitEditKeys);
+  let end = delegate.decorateInput(conn, `${name}:source(${ast.table})`);
+  const { fullyAppliedFilters } = conn;
   if (ast.start) {
-    end = new Skip(end, ast.start);
+    end = delegate.decorateInput(new Skip(end, ast.start), `${name}:skip)`);
   }
-  for (const csq of gatherCorrelatedSubqueryQueriesFromCondition(ast.where)) {
-    end = applyCorrelatedSubQuery(csq, delegate, end);
+  for (const csq of csqsFromCondition) {
+    end = applyCorrelatedSubQuery(csq, delegate, end, name);
   }
   if (ast.where && !fullyAppliedFilters) {
-    end = applyWhere(end, ast.where, delegate);
+    end = applyWhere(end, ast.where, delegate, name);
   }
-  if (ast.limit) {
-    end = new Take(end, delegate.createStorage(), ast.limit, partitionKey);
+  if (ast.limit !== void 0) {
+    const takeName = `${name}:take`;
+    end = delegate.decorateInput(
+      new Take(end, delegate.createStorage(takeName), ast.limit, partitionKey),
+      takeName
+    );
   }
   if (ast.related) {
     for (const csq of ast.related) {
-      end = applyCorrelatedSubQuery(csq, delegate, end);
+      end = applyCorrelatedSubQuery(csq, delegate, end, name);
     }
   }
   return end;
 }
-function applyWhere(input, condition, delegate) {
+function applyWhere(input, condition, delegate, name) {
   switch (condition.type) {
     case "and":
-      return applyAnd(input, condition, delegate);
+      return applyAnd(input, condition, delegate, name);
     case "or":
-      return applyOr(input, condition, delegate);
+      return applyOr(input, condition, delegate, name);
     case "correlatedSubquery":
-      return applyCorrelatedSubqueryCondition(input, condition, delegate);
+      return applyCorrelatedSubqueryCondition(input, condition, delegate, name);
     case "simple":
       return applySimpleCondition(input, condition);
   }
 }
-function applyAnd(input, condition, delegate) {
+function applyAnd(input, condition, delegate, name) {
   for (const subCondition of condition.conditions) {
-    input = applyWhere(input, subCondition, delegate);
+    input = applyWhere(input, subCondition, delegate, name);
   }
   return input;
 }
-function applyOr(input, condition, delegate) {
+function applyOr(input, condition, delegate, name) {
   const [subqueryConditions, otherConditions] = groupSubqueryConditions(condition);
   if (subqueryConditions.length === 0) {
     return new Filter(
@@ -10582,7 +10839,7 @@ function applyOr(input, condition, delegate) {
   }
   const fanOut = new FanOut(input);
   const branches = subqueryConditions.map(
-    (subCondition) => applyWhere(fanOut, subCondition, delegate)
+    (subCondition) => applyWhere(fanOut, subCondition, delegate, name)
   );
   if (otherConditions.length > 0) {
     branches.push(
@@ -10595,7 +10852,9 @@ function applyOr(input, condition, delegate) {
       )
     );
   }
-  return new FanIn(fanOut, branches);
+  const ret = new FanIn(fanOut, branches);
+  fanOut.setFanIn(ret);
+  return ret;
 }
 function groupSubqueryConditions(condition) {
   const partitioned = [[], []];
@@ -10621,33 +10880,39 @@ function isNotAndDoesNotContainSubquery(condition) {
 function applySimpleCondition(input, condition) {
   return new Filter(input, createPredicate(condition));
 }
-function applyCorrelatedSubQuery(sq, delegate, end) {
+function applyCorrelatedSubQuery(sq, delegate, end, name) {
   assert(sq.subquery.alias, "Subquery must have an alias");
   const child = buildPipelineInternal(
     sq.subquery,
     delegate,
+    `${name}.${sq.subquery.alias}`,
     sq.correlation.childField
   );
+  const joinName = `${name}:join(${sq.subquery.alias})`;
   end = new Join({
     parent: end,
     child,
-    storage: delegate.createStorage(),
+    storage: delegate.createStorage(joinName),
     parentKey: sq.correlation.parentField,
     childKey: sq.correlation.childField,
     relationshipName: sq.subquery.alias,
     hidden: sq.hidden ?? false,
     system: sq.system ?? "client"
   });
-  return end;
+  return delegate.decorateInput(end, joinName);
 }
-function applyCorrelatedSubqueryCondition(input, condition, delegate) {
+function applyCorrelatedSubqueryCondition(input, condition, delegate, name) {
   assert(condition.op === "EXISTS" || condition.op === "NOT EXISTS");
-  return new Exists(
-    input,
-    delegate.createStorage(),
-    must(condition.related.subquery.alias),
-    condition.related.correlation.parentField,
-    condition.op
+  const existsName = `${name}:exists(${condition.related.subquery.alias})`;
+  return delegate.decorateInput(
+    new Exists(
+      input,
+      delegate.createStorage(existsName),
+      must(condition.related.subquery.alias),
+      condition.related.correlation.parentField,
+      condition.op
+    ),
+    existsName
   );
 }
 function gatherCorrelatedSubqueryQueriesFromCondition(condition) {
@@ -11044,9 +11309,6 @@ 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) {
@@ -11085,9 +11347,7 @@ var AbstractQuery = class {
   }
   hash() {
     if (!this.#hash) {
-      const ast = this._completeAst();
-      const hash2 = hashOfAST(ast);
-      this.#hash = hash2;
+      this.#hash = hashOfAST(this._completeAst());
     }
     return this.#hash;
   }
@@ -11452,6 +11712,7 @@ var QueryImpl = class extends AbstractQuery {
     return newQueryWithDetails(this.#delegate, schema, tableName, ast, format);
   }
   materialize(factoryOrTTL, ttl = DEFAULT_TTL) {
+    const t0 = Date.now();
     let factory;
     if (typeof factoryOrTTL === "function") {
       factory = factoryOrTTL;
@@ -11463,6 +11724,8 @@ var QueryImpl = class extends AbstractQuery {
     let queryGot = false;
     const removeServerQuery = this.#delegate.addServerQuery(ast, ttl, (got) => {
       if (got) {
+        const t1 = Date.now();
+        this.#delegate.onQueryMaterialized(this.hash(), ast, t1 - t0);
         queryGot = true;
         queryCompleteResolver.resolve(true);
       }
@@ -11875,6 +12138,7 @@ var connectedMessageSchema = valita_exports.tuple([
 ]);
 var initConnectionBodySchema = valita_exports.object({
   desiredQueriesPatch: queriesPatchSchema,
+  clientSchema: clientSchemaSchema.optional(),
   deleted: deleteClientsBodySchema.optional()
 });
 var initConnectionMessageSchema = valita_exports.tuple([
@@ -12103,7 +12367,7 @@ var CRUD = "crud";
 var Custom = "custom";
 
 // ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 6;
+var PROTOCOL_VERSION = 7;
 var MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 2;
 assert(MIN_SERVER_SUPPORTED_SYNC_PROTOCOL < PROTOCOL_VERSION);
 var MIN_SERVER_SUPPORTED_PERMISSIONS_PROTOCOL = 4;
@@ -12168,7 +12432,10 @@ var pushBodySchema = valita_exports.object({
   clientGroupID: valita_exports.string(),
   mutations: valita_exports.array(mutationSchema),
   pushVersion: valita_exports.number(),
-  schemaVersion: valita_exports.number(),
+  // For legacy (CRUD) mutations, the schema is tied to the client group /
+  // sync connection. For custom mutations, schema versioning is delegated
+  // to the custom protocol / api-server.
+  schemaVersion: valita_exports.number().optional(),
   timestamp: valita_exports.number(),
   requestID: valita_exports.string()
 });
@@ -12811,6 +13078,7 @@ var MemorySource = class _MemorySource {
   #indexes = /* @__PURE__ */ new Map();
   #connections = [];
   #overlay;
+  #splitEditOverlay;
   constructor(tableName, columns, primaryKey, primaryIndexData) {
     this.#tableName = tableName;
     this.#columns = columns;
@@ -12853,7 +13121,7 @@ var MemorySource = class _MemorySource {
       compareRows: connection.compareRows
     };
   }
-  connect(sort, filters) {
+  connect(sort, filters, splitEditKeys) {
     const transformedFilters = transformFilters(filters);
     const input = {
       getSchema: () => schema,
@@ -12871,6 +13139,7 @@ var MemorySource = class _MemorySource {
       input,
       output: void 0,
       sort,
+      splitEditKeys,
       compareRows: makeComparator(sort),
       filters: transformedFilters.filters ? {
         condition: transformedFilters.filters,
@@ -12924,10 +13193,9 @@ var MemorySource = class _MemorySource {
     return [...this.#indexes.keys()];
   }
   *#fetch(req, from) {
-    let overlay;
-    const callingConnectionNum = this.#connections.indexOf(from);
-    assert(callingConnectionNum !== -1, "Output not found");
-    const conn = this.#connections[callingConnectionNum];
+    const callingConnectionIndex = this.#connections.indexOf(from);
+    assert(callingConnectionIndex !== -1, "Output not found");
+    const conn = this.#connections[callingConnectionIndex];
     const { sort: requestedSort } = conn;
     const indexSort = [];
     if (req.constraint) {
@@ -12941,11 +13209,6 @@ var MemorySource = class _MemorySource {
     const index = this.#getOrCreateIndex(indexSort, from);
     const { data, comparator: compare } = index;
     const comparator2 = (r1, r2) => compare(r1, r2) * (req.reverse ? -1 : 1);
-    if (this.#overlay) {
-      if (callingConnectionNum <= this.#overlay.outputIndex) {
-        overlay = this.#overlay;
-      }
-    }
     const startAt = req.start?.row;
     let scanStart;
     if (req.constraint) {
@@ -12968,7 +13231,9 @@ var MemorySource = class _MemorySource {
       startAt,
       generateRows(data, scanStart, req.reverse),
       req.constraint,
-      overlay,
+      this.#overlay,
+      this.#splitEditOverlay,
+      callingConnectionIndex,
       comparator2,
       conn.filters?.predicate
     );
@@ -12988,56 +13253,18 @@ var MemorySource = class _MemorySource {
   *genPush(change) {
     const primaryIndex = this.#getPrimaryIndex();
     const { data } = primaryIndex;
-    switch (change.type) {
-      case "add":
-        assert(
-          !data.has(change.row),
-          () => `Row already exists ${JSON.stringify(change)}`
-        );
-        break;
-      case "remove":
-        assert(
-          data.has(change.row),
-          () => `Row not found ${JSON.stringify(change)}`
-        );
-        break;
-      case "edit":
-        assert(
-          data.has(change.oldRow),
-          () => `Row not found ${JSON.stringify(change)}`
-        );
-        break;
-      default:
-        unreachable(change);
-    }
-    const outputChange = change.type === "edit" ? {
-      type: change.type,
-      oldNode: {
-        row: change.oldRow,
-        relationships: {}
-      },
-      node: {
-        row: change.row,
-        relationships: {}
-      }
-    } : {
-      type: change.type,
-      node: {
-        row: change.row,
-        relationships: {}
-      }
-    };
-    for (const [
-      outputIndex,
-      { output, filters }
-    ] of this.#connections.entries()) {
-      if (output) {
-        this.#overlay = { outputIndex, change };
-        filterPush(outputChange, output, filters?.predicate);
-        yield;
-      }
+    const exists = (row) => data.has(row);
+    const setOverlay = (o) => this.#overlay = o;
+    const setSplitEditOverlay = (o) => this.#splitEditOverlay = o;
+    for (const x of genPush(
+      change,
+      exists,
+      this.#connections.entries(),
+      setOverlay,
+      setSplitEditOverlay
+    )) {
+      yield x;
     }
-    this.#overlay = void 0;
     for (const { data: data2 } of this.#indexes.values()) {
       switch (change.type) {
         case "add": {
@@ -13077,6 +13304,89 @@ function* generateWithFilter(it, filter) {
     }
   }
 }
+function* genPush(change, exists, connections, setOverlay, setSplitEditOverlay) {
+  switch (change.type) {
+    case "add":
+      assert(
+        !exists(change.row),
+        () => `Row already exists ${stringify(change)}`
+      );
+      break;
+    case "remove":
+      assert(exists(change.row), () => `Row not found ${stringify(change)}`);
+      break;
+    case "edit":
+      assert(exists(change.oldRow), () => `Row not found ${stringify(change)}`);
+      break;
+    default:
+      unreachable(change);
+  }
+  for (const [outputIndex, { output, splitEditKeys, filters }] of connections) {
+    if (output) {
+      let splitEdit = false;
+      if (change.type === "edit" && splitEditKeys) {
+        for (const key of splitEditKeys) {
+          if (!valuesEqual(change.row[key], change.oldRow[key])) {
+            splitEdit = true;
+            break;
+          }
+        }
+      }
+      if (splitEdit) {
+        assert(change.type === "edit");
+        setSplitEditOverlay({
+          outputIndex,
+          change: {
+            type: "remove",
+            row: change.oldRow
+          }
+        });
+        const outputRemove = {
+          type: "remove",
+          node: {
+            row: change.oldRow,
+            relationships: {}
+          }
+        };
+        filterPush(outputRemove, output, filters?.predicate);
+        yield;
+        setSplitEditOverlay(void 0);
+        setOverlay({ outputIndex, change });
+        const outputAdd = {
+          type: "add",
+          node: {
+            row: change.row,
+            relationships: {}
+          }
+        };
+        filterPush(outputAdd, output, filters?.predicate);
+        yield;
+      } else {
+        setOverlay({ outputIndex, change });
+        const outputChange = change.type === "edit" ? {
+          type: change.type,
+          oldNode: {
+            row: change.oldRow,
+            relationships: {}
+          },
+          node: {
+            row: change.row,
+            relationships: {}
+          }
+        } : {
+          type: change.type,
+          node: {
+            row: change.row,
+            relationships: {}
+          }
+        };
+        filterPush(outputChange, output, filters?.predicate);
+        yield;
+      }
+    }
+  }
+  setOverlay(void 0);
+}
 function* generateWithStart(nodes, start, compare) {
   if (!start) {
     yield* nodes;
@@ -13100,11 +13410,17 @@ function* generateWithStart(nodes, start, compare) {
     }
   }
 }
-function* generateWithOverlay(startAt, rows, constraint, overlay, compare, filterPredicate) {
+function* generateWithOverlay(startAt, rows, constraint, overlay, splitEditOverlay, connectionIndex, compare, filterPredicate) {
+  let overlayToApply = void 0;
+  if (splitEditOverlay && splitEditOverlay.outputIndex === connectionIndex) {
+    overlayToApply = splitEditOverlay;
+  } else if (overlay && connectionIndex <= overlay.outputIndex) {
+    overlayToApply = overlay;
+  }
   const overlays = computeOverlays(
     startAt,
     constraint,
-    overlay,
+    overlayToApply,
     compare,
     filterPredicate
   );
@@ -13228,6 +13544,12 @@ function* generateRows(data, scanStart, reverse) {
     scanStart
   );
 }
+function stringify(change) {
+  return JSON.stringify(
+    change,
+    (_, v2) => typeof v2 === "bigint" ? v2.toString() : v2
+  );
+}
 
 // ../zero-client/src/client/keys.ts
 var DESIRED_QUERIES_KEY_PREFIX = "d/";
@@ -13393,11 +13715,15 @@ var ZeroContext = class {
   #addQuery;
   #batchViewUpdates;
   #commitListeners = /* @__PURE__ */ new Set();
+  slowMaterializeThreshold;
+  lc;
   staticQueryParameters = void 0;
-  constructor(mainSources, addQuery, batchViewUpdates) {
+  constructor(lc, mainSources, addQuery, batchViewUpdates, slowMaterializeThreshold) {
     this.#mainSources = mainSources;
     this.#addQuery = addQuery;
     this.#batchViewUpdates = batchViewUpdates;
+    this.lc = lc;
+    this.slowMaterializeThreshold = slowMaterializeThreshold;
   }
   getSource(name) {
     return this.#mainSources.getSource(name);
@@ -13405,9 +13731,29 @@ var ZeroContext = class {
   addServerQuery(ast, ttl, gotCallback) {
     return this.#addQuery(ast, ttl, gotCallback);
   }
+  onQueryMaterialized(hash2, ast, duration) {
+    if (this.slowMaterializeThreshold !== void 0 && duration > this.slowMaterializeThreshold) {
+      this.lc.warn?.(
+        "Slow query materialization (including server/network)",
+        hash2,
+        ast,
+        duration
+      );
+    } else {
+      this.lc.debug?.(
+        "Materialized query (including server/network)",
+        hash2,
+        ast,
+        duration
+      );
+    }
+  }
   createStorage() {
     return new MemoryStorage();
   }
+  decorateInput(input) {
+    return input;
+  }
   onTransactionCommit(cb) {
     this.#commitListeners.add(cb);
     return () => {
@@ -14062,7 +14408,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.17.2025030701";
+var version2 = "0.17.2025031200";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14431,7 +14777,7 @@ var QueryManager = class {
     }
     for (const [hash2, { normalized, ttl }] of this.#queries) {
       if (!existingQueryHashes.has(hash2)) {
-        patch.set(hash2, { op: "put", hash: hash2, ast: normalized, ttl });
+        patch.set(hash2, { op: "put", hash: hash2, ast: normalized, ttl: parseTTL(ttl) });
       }
     }
     if (lastPatch) {
@@ -14459,7 +14805,7 @@ var QueryManager = class {
       entry = {
         normalized: serverAST,
         count: 1,
-        gotCallbacks: gotCallback === void 0 ? [] : [gotCallback],
+        gotCallbacks: gotCallback ? [gotCallback] : [],
         ttl
       };
       this.#queries.set(astHash, entry);
@@ -14467,19 +14813,24 @@ var QueryManager = class {
         "changeDesiredQueries",
         {
           desiredQueriesPatch: [
-            { op: "put", hash: astHash, ast: serverAST, ttl }
+            { op: "put", hash: astHash, ast: serverAST, ttl: parseTTL(ttl) }
           ]
         }
       ]);
     } else {
       ++entry.count;
-      if (ttl !== void 0 && (entry.ttl === void 0 || ttl > entry.ttl)) {
+      if (compareTTL(ttl, entry.ttl) > 0) {
         entry.ttl = ttl;
         this.#send([
           "changeDesiredQueries",
           {
             desiredQueriesPatch: [
-              { op: "put", hash: astHash, ast: entry.normalized, ttl }
+              {
+                op: "put",
+                hash: astHash,
+                ast: entry.normalized,
+                ttl: parseTTL(ttl)
+              }
             ]
           }
         ]);
@@ -14497,11 +14848,10 @@ var QueryManager = class {
         return;
       }
       removed = true;
-      this.#remove(astHash, gotCallback);
+      this.#remove(entry, astHash, gotCallback);
     };
   }
-  #remove(astHash, gotCallback) {
-    const entry = must(this.#queries.get(astHash));
+  #remove(entry, astHash, gotCallback) {
     if (gotCallback) {
       const index = entry.gotCallbacks.indexOf(gotCallback);
       entry.gotCallbacks.splice(index, 1);
@@ -14998,7 +15348,7 @@ function updateNeededReloadReason(reason, serverErrMsg) {
       reasonMsg = "The server no longer supports this client's protocol version.";
       break;
     case "SchemaVersionNotSupported":
-      reasonMsg = "The server no longer supports this client's schema version.";
+      reasonMsg = "Client and server schemas incompatible.";
       break;
     default:
       unreachable(type);
@@ -15025,6 +15375,7 @@ var Zero = class {
   #lc;
   #logOptions;
   #enableAnalytics;
+  #clientSchema;
   #pokeHandler;
   #queryManager;
   #ivmMain;
@@ -15122,7 +15473,8 @@ var Zero = class {
       hiddenTabDisconnectDelay = DEFAULT_DISCONNECT_HIDDEN_DELAY_MS,
       schema,
       batchViewUpdates = (applyViewUpdates) => applyViewUpdates(),
-      maxRecentQueries = 0
+      maxRecentQueries = 0,
+      slowMaterializeThreshold = 5e3
     } = options;
     if (!userID) {
       throw new Error("ZeroOptions.userID must not be empty.");
@@ -15170,10 +15522,12 @@ var Zero = class {
       }
     }
     this.storageKey = storageKey ?? "";
+    const { clientSchema: clientSchema2, hash: hash2 } = clientSchemaFrom(schema);
+    this.#clientSchema = clientSchema2;
     const replicacheOptions = {
-      // The schema stored in IDB is dependent upon both the application schema
+      // The schema stored in IDB is dependent upon both the ClientSchema
       // and the AST schema (i.e. PROTOCOL_VERSION).
-      schemaVersion: `${schema.version}.${PROTOCOL_VERSION}`,
+      schemaVersion: `${PROTOCOL_VERSION}.${hash2}`,
       logLevel: logOptions.logLevel,
       logSinks: [logOptions.logSink],
       mutators: replicacheMutators,
@@ -15260,9 +15614,11 @@ var Zero = class {
       this.#lc
     );
     this.#zeroContext = new ZeroContext(
+      this.#lc,
       this.#ivmMain,
       (ast, ttl, gotCallback) => this.#queryManager.add(ast, ttl, gotCallback),
-      batchViewUpdates
+      batchViewUpdates,
+      slowMaterializeThreshold
     );
     rep.experimentalWatch(
       (diff3) => this.#zeroContext.processChanges(diff3),
@@ -15470,10 +15826,14 @@ var Zero = class {
       case "error":
         return this.#handleErrorMessage(lc, downMessage);
       case "pong":
+        resetBackoff();
         return this.#onPong();
       case "pokeStart":
         return this.#handlePokeStart(lc, downMessage);
       case "pokePart":
+        if (downMessage[1].rowsPatch) {
+          resetBackoff();
+        }
         return this.#handlePokePart(lc, downMessage);
       case "pokeEnd":
         return this.#handlePokeEnd(lc, downMessage);
@@ -15607,11 +15967,15 @@ var Zero = class {
         }
       ]);
     } else if (this.#initConnectionQueries === void 0) {
+      const clientSchema2 = this.#clientSchema;
       send(socket, [
         "initConnection",
         {
           desiredQueriesPatch: [...queriesPatch.values()],
-          deleted: skipEmptyDeletedClients(this.#deletedClients)
+          deleted: skipEmptyDeletedClients(this.#deletedClients),
+          // The clientSchema only needs to be sent for the very first request.
+          // Henceforth it is stored with the CVR and verified automatically.
+          ...this.#connectCookie === null ? { clientSchema: clientSchema2 } : {}
         }
       ]);
       this.#deletedClients = void 0;
@@ -15679,7 +16043,7 @@ var Zero = class {
       this.#connectCookie,
       this.clientID,
       await this.clientGroupID,
-      this.#options.schema.version,
+      this.#clientSchema,
       this.userID,
       this.#rep.auth,
       this.#lastMutationIDReceived,
@@ -15775,7 +16139,6 @@ var Zero = class {
     );
   }
   #handlePokeStart(_lc, pokeMessage) {
-    resetBackoff();
     this.#abortPingTimeout();
     this.#pokeHandler.handlePokeStart(pokeMessage[1]);
   }
@@ -15860,8 +16223,6 @@ var Zero = class {
           clientGroupID: req.clientGroupID,
           mutations: [zeroM],
           pushVersion: req.pushVersion,
-          // Zero schema versions are always numbers.
-          schemaVersion: parseInt(req.schemaVersion),
           requestID
         }
       ];
@@ -16106,7 +16467,7 @@ var Zero = class {
     return this.#online;
   }
   /**
-   * Starts a a ping and waits for a pong.
+   * Starts a ping and waits for a pong.
    *
    * If it takes too long to get a pong we disconnect and this returns
    * {@code PingResult.TimedOut}.
@@ -16154,14 +16515,13 @@ var Zero = class {
     return rv;
   }
 };
-async function createSocket(rep, queryManager, deleteClientsManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8, additionalConnectParams) {
+async function createSocket(rep, queryManager, deleteClientsManager, socketOrigin, baseCookie, clientID, clientGroupID, clientSchema2, userID, auth, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8, additionalConnectParams) {
   const url = new URL(
     appendPath(socketOrigin, `/sync/v${PROTOCOL_VERSION}/connect`)
   );
   const { searchParams } = url;
   searchParams.set("clientID", clientID);
   searchParams.set("clientGroupID", clientGroupID);
-  searchParams.set("schemaVersion", schemaVersion.toString());
   searchParams.set("userID", userID);
   searchParams.set("baseCookie", baseCookie === null ? "" : String(baseCookie));
   searchParams.set("ts", String(performance.now()));
@@ -16189,7 +16549,10 @@ async function createSocket(rep, queryManager, deleteClientsManager, socketOrigi
       "initConnection",
       {
         desiredQueriesPatch: [...queriesPatch.values()],
-        deleted: skipEmptyDeletedClients(deletedClients)
+        deleted: skipEmptyDeletedClients(deletedClients),
+        // The clientSchema only needs to be sent for the very first request.
+        // Henceforth it is stored with the CVR and verified automatically.
+        ...baseCookie === null ? { clientSchema: clientSchema2 } : {}
       }
     ],
     auth
@@ -16266,4 +16629,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-YKI43S5O.js.map
+//# sourceMappingURL=chunk-VNV6U5BQ.js.map