@rocicorp/zero 0.6.2024112102 → 0.7.2024112700

package/out/{chunk-QB7G63C6.js → chunk-HDEKBM3G.js}

@@ -14,7 +14,7 @@ import {
   must,
   throwInvalidType,
   unreachable
-} from "./chunk-5UY46OAF.js";
+} from "./chunk-C7M3BJ3Z.js";
 import {
   __export,
   __reExport
@@ -9291,8 +9291,8 @@ function isJunctionRelationship(relationship) {
 }
 
 // ../shared/src/sorted-entries.ts
-function sortedEntries(object16) {
-  return Object.entries(object16).sort((a, b) => stringCompare(a[0], b[0]));
+function sortedEntries(object17) {
+  return Object.entries(object17).sort((a, b) => stringCompare(a[0], b[0]));
 }
 
 // ../zero-schema/src/normalize-table-schema.ts
@@ -9409,22 +9409,11 @@ function normalizeFieldRelationship(relationship, tableSchemaCache) {
 }
 function normalizeJunctionRelationship(relationship, tableSchemaCache) {
   return {
-    source: relationship.source,
-    junction: {
-      sourceField: relationship.junction.sourceField,
-      destField: relationship.junction.destField,
-      schema: normalizeLazyTableSchema(
-        relationship.junction.schema,
-        tableSchemaCache
-      )
-    },
-    dest: {
-      field: relationship.dest.field,
-      schema: normalizeLazyTableSchema(
-        relationship.dest.schema,
-        tableSchemaCache
-      )
-    }
+    ...normalizeFieldRelationship(relationship, tableSchemaCache),
+    junction: normalizeFieldRelationship(
+      relationship.junction,
+      tableSchemaCache
+    )
   };
 }
 function normalizeLazyTableSchema(tableSchema, buildCache) {
@@ -9461,6 +9450,158 @@ function normalizeTables(tables) {
   return rv;
 }
 
+// ../zql/src/query/expression.ts
+var ExpressionBuilder = class {
+  #exists;
+  constructor(exists) {
+    this.#exists = exists;
+    this.exists = this.exists.bind(this);
+  }
+  get eb() {
+    return this;
+  }
+  cmp(field, opOrValue, value) {
+    return cmp(field, opOrValue, value);
+  }
+  cmpLit(left, op, right) {
+    return {
+      type: "simple",
+      left: isParameter(left) ? left : { type: "literal", value: left },
+      right: isParameter(right) ? right : { type: "literal", value: right },
+      op
+    };
+  }
+  and = and;
+  or = or;
+  not = not;
+  exists(relationship, cb) {
+    return this.#exists(relationship, cb);
+  }
+};
+function and(...conditions) {
+  const expressions = filterTrue(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
+  }
+  if (expressions.some(isAlwaysFalse)) {
+    return FALSE;
+  }
+  return { type: "and", conditions: expressions };
+}
+function or(...conditions) {
+  const expressions = filterFalse(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
+  }
+  if (expressions.some(isAlwaysTrue)) {
+    return TRUE;
+  }
+  return { type: "or", conditions: expressions };
+}
+function not(expression) {
+  switch (expression.type) {
+    case "and":
+      return {
+        type: "or",
+        conditions: expression.conditions.map(not)
+      };
+    case "or":
+      return {
+        type: "and",
+        conditions: expression.conditions.map(not)
+      };
+    case "correlatedSubquery":
+      return {
+        type: "correlatedSubquery",
+        related: expression.related,
+        op: negateOperator(expression.op)
+      };
+    case "simple":
+      return {
+        type: "simple",
+        op: negateOperator(expression.op),
+        left: expression.left,
+        right: expression.right
+      };
+  }
+}
+function cmp(field, opOrValue, value) {
+  let op;
+  if (value === void 0) {
+    value = opOrValue;
+    op = "=";
+  } else {
+    op = opOrValue;
+  }
+  return {
+    type: "simple",
+    left: { type: "column", name: field },
+    right: isParameter(value) ? value : { type: "literal", value },
+    op
+  };
+}
+function isParameter(value) {
+  return typeof value === "object" && value?.type === "static";
+}
+var TRUE = {
+  type: "and",
+  conditions: []
+};
+var FALSE = {
+  type: "or",
+  conditions: []
+};
+function isAlwaysTrue(condition) {
+  return condition.type === "and" && condition.conditions.length === 0;
+}
+function isAlwaysFalse(condition) {
+  return condition.type === "or" && condition.conditions.length === 0;
+}
+function flatten(type, conditions) {
+  const flattened2 = [];
+  for (const c of conditions) {
+    if (c.type === type) {
+      flattened2.push(...c.conditions);
+    } else {
+      flattened2.push(c);
+    }
+  }
+  return flattened2;
+}
+var negateSimpleOperatorMap = {
+  ["="]: "!=",
+  ["!="]: "=",
+  ["<"]: ">=",
+  [">"]: "<=",
+  [">="]: "<",
+  ["<="]: ">",
+  ["IN"]: "NOT IN",
+  ["NOT IN"]: "IN",
+  ["LIKE"]: "NOT LIKE",
+  ["NOT LIKE"]: "LIKE",
+  ["ILIKE"]: "NOT ILIKE",
+  ["NOT ILIKE"]: "ILIKE",
+  ["IS"]: "IS NOT",
+  ["IS NOT"]: "IS"
+};
+var negateOperatorMap = {
+  ...negateSimpleOperatorMap,
+  ["EXISTS"]: "NOT EXISTS",
+  ["NOT EXISTS"]: "EXISTS"
+};
+function negateOperator(op) {
+  return must(negateOperatorMap[op]);
+}
+function filterUndefined(array9) {
+  return array9.filter((e) => e !== void 0);
+}
+function filterTrue(conditions) {
+  return conditions.filter((c) => !isAlwaysTrue(c));
+}
+function filterFalse(conditions) {
+  return conditions.filter((c) => !isAlwaysFalse(c));
+}
+
 // ../zql/src/query/query-impl.ts
 import { resolver as resolver7 } from "@rocicorp/resolver";
 
@@ -9753,7 +9894,7 @@ function hashOfAST(ast) {
 // ../zql/src/ivm/change.ts
 function rowForChange(change) {
   const { type } = change;
-  return type === "add" || type === "remove" ? change.node.row : change.row;
+  return type === "child" ? change.row : change.node.row;
 }
 
 // ../zql/src/ivm/data.ts
@@ -9895,8 +10036,12 @@ var Exists = class {
               size = this.#fetchSize(change.row);
             }
             if (size === 1) {
+              const type = this.#not ? "remove" : "add";
+              if (type === "remove") {
+                this.#output.push(change);
+              }
               this.#output.push({
-                type: this.#not ? "remove" : "add",
+                type,
                 node: this.#fetchNodeForRow(change.row)
               });
             } else {
@@ -9914,8 +10059,12 @@ var Exists = class {
               size = this.#fetchSize(change.row);
             }
             if (size === 0) {
+              const type = this.#not ? "add" : "remove";
+              if (type === "remove") {
+                this.#output.push(change);
+              }
               this.#output.push({
-                type: this.#not ? "add" : "remove",
+                type,
                 node: this.#fetchNodeForRow(change.row)
               });
             } else {
@@ -10092,25 +10241,19 @@ var FanOut = class {
 
 // ../zql/src/ivm/maybe-split-and-push-edit-change.ts
 function maybeSplitAndPushEditChange(change, predicate, output) {
-  const oldWasPresent = predicate(change.oldRow);
-  const newIsPresent = predicate(change.row);
+  const oldWasPresent = predicate(change.oldNode.row);
+  const newIsPresent = predicate(change.node.row);
   if (oldWasPresent && newIsPresent) {
     output.push(change);
   } else if (oldWasPresent && !newIsPresent) {
     output.push({
       type: "remove",
-      node: {
-        row: change.oldRow,
-        relationships: {}
-      }
+      node: change.oldNode
     });
   } else if (!oldWasPresent && newIsPresent) {
     output.push({
       type: "add",
-      node: {
-        row: change.row,
-        relationships: {}
-      }
+      node: change.node
     });
   }
 }
@@ -10192,6 +10335,10 @@ var Join = class {
     hidden
   }) {
     assert(parent !== child, "Parent and child must be different operators");
+    assert(
+      parentKey.length === childKey.length,
+      "The parentKey and childKey keys must have same length"
+    );
     this.#parent = parent;
     this.#child = child;
     this.#storage = storage;
@@ -10270,68 +10417,33 @@ var Join = class {
         this.#output.push(change);
         break;
       case "edit": {
-        this.#output.push({
-          type: "edit",
-          row: change.row,
-          oldRow: change.oldRow
-        });
-        const oldKeyValue = normalizeUndefined(change.oldRow[this.#parentKey]);
-        const newKeyValue = normalizeUndefined(change.row[this.#parentKey]);
-        if (newKeyValue !== oldKeyValue) {
-          const childrenToRemoveStream = this.#child.cleanup({
-            constraint: {
-              key: this.#childKey,
-              value: oldKeyValue
-            }
+        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"
+            )
           });
-          for (const childNode of childrenToRemoveStream) {
-            this.#output.push({
-              type: "child",
-              // This is the new row since we already changed it in the edit above.
-              row: change.row,
-              child: {
-                relationshipName: this.#relationshipName,
-                change: {
-                  type: "remove",
-                  node: childNode
-                }
-              }
-            });
-          }
-          const childrenToAddStream = this.#child.fetch({
-            constraint: {
-              key: this.#childKey,
-              value: newKeyValue
-            }
+        } else {
+          this.#pushParent({
+            type: "remove",
+            node: change.oldNode
+          });
+          this.#pushParent({
+            type: "add",
+            node: change.node
           });
-          for (const childNode of childrenToAddStream) {
-            this.#output.push({
-              type: "child",
-              row: change.row,
-              child: {
-                relationshipName: this.#relationshipName,
-                change: {
-                  type: "add",
-                  node: childNode
-                }
-              }
-            });
-          }
-        }
-        const { primaryKey } = this.#parent.getSchema();
-        const oldStorageKey = makeStorageKey(
-          oldKeyValue,
-          primaryKey,
-          change.oldRow
-        );
-        const newStorageKey = makeStorageKey(
-          newKeyValue,
-          primaryKey,
-          change.row
-        );
-        if (oldStorageKey !== newStorageKey) {
-          this.#storage.del(oldStorageKey);
-          this.#storage.set(newStorageKey, true);
         }
         break;
       }
@@ -10343,10 +10455,9 @@ var Join = class {
     const pushChildChange = (childRow, change2) => {
       assert(this.#output, "Output not set");
       const parentNodes = this.#parent.fetch({
-        constraint: {
-          key: this.#parentKey,
-          value: childRow[this.#childKey]
-        }
+        constraint: Object.fromEntries(
+          this.#parentKey.map((key, i) => [key, childRow[this.#childKey[i]]])
+        )
       });
       for (const parentNode of parentNodes) {
         const childChange = {
@@ -10369,34 +10480,18 @@ var Join = class {
         pushChildChange(change.row, change);
         break;
       case "edit": {
-        const childRow = change.row;
-        const oldChildRow = change.oldRow;
-        if (normalizeUndefined(oldChildRow[this.#childKey]) === normalizeUndefined(childRow[this.#childKey])) {
+        const childRow = change.node.row;
+        const oldChildRow = change.oldNode.row;
+        if (rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey)) {
           pushChildChange(childRow, change);
         } else {
-          const { relationships } = must(
-            first(
-              this.#child.fetch({
-                constraint: {
-                  key: this.#childKey,
-                  value: oldChildRow[this.#childKey]
-                }
-              })
-            )
-          );
           pushChildChange(oldChildRow, {
             type: "remove",
-            node: {
-              row: oldChildRow,
-              relationships
-            }
+            node: change.oldNode
           });
           pushChildChange(childRow, {
             type: "add",
-            node: {
-              row: childRow,
-              relationships
-            }
+            node: change.node
           });
         }
         break;
@@ -10406,9 +10501,8 @@ var Join = class {
     }
   }
   #processParentNode(parentNodeRow, parentNodeRelations, mode) {
-    const parentKeyValue = normalizeUndefined(parentNodeRow[this.#parentKey]);
     const storageKey = makeStorageKey(
-      parentKeyValue,
+      this.#parentKey,
       this.#parent.getSchema().primaryKey,
       parentNodeRow
     );
@@ -10416,17 +10510,19 @@ var Join = class {
     if (mode === "cleanup") {
       const [, second] = take(
         this.#storage.scan({
-          prefix: createPrimaryKeySetStorageKeyPrefix(parentKeyValue)
+          prefix: makeStorageKeyPrefix(parentNodeRow, this.#parentKey)
         }),
         2
       );
       method = second ? "fetch" : "cleanup";
     }
     const childStream = this.#child[method]({
-      constraint: {
-        key: this.#childKey,
-        value: parentKeyValue
-      }
+      constraint: Object.fromEntries(
+        this.#childKey.map((key, i) => [
+          key,
+          parentNodeRow[this.#parentKey[i]]
+        ])
+      )
     });
     if (mode === "fetch") {
       this.#storage.set(storageKey, true);
@@ -10443,19 +10539,27 @@ var Join = class {
     };
   }
 };
-function createPrimaryKeySetStorageKey(values) {
+function makeStorageKeyForValues(values) {
   const json = JSON.stringify(["pKeySet", ...values]);
   return json.substring(1, json.length - 1) + ",";
 }
-function createPrimaryKeySetStorageKeyPrefix(value) {
-  return createPrimaryKeySetStorageKey([value]);
+function makeStorageKeyPrefix(row, key) {
+  return makeStorageKeyForValues(key.map((k) => row[k]));
 }
-function makeStorageKey(keyValue, primaryKey, row) {
-  const parentPrimaryKey = [keyValue];
-  for (const key of primaryKey) {
-    parentPrimaryKey.push(normalizeUndefined(row[key]));
+function makeStorageKey(key, primaryKey, row) {
+  const values = key.map((k) => row[k]);
+  for (const key2 of primaryKey) {
+    values.push(row[key2]);
   }
-  return createPrimaryKeySetStorageKey(parentPrimaryKey);
+  return makeStorageKeyForValues(values);
+}
+function rowEqualsForCompoundKey(a, b, key) {
+  for (let i = 0; i < key.length; i++) {
+    if (!valuesEqual(a[key[i]], b[key[i]])) {
+      return false;
+    }
+  }
+  return true;
 }
 
 // ../zql/src/ivm/skip.ts
@@ -10551,18 +10655,20 @@ var Take = class {
   #storage;
   #limit;
   #partitionKey;
+  #partitionKeyComparator;
   #output = null;
   constructor(input, storage, limit, partitionKey) {
-    this.#input = input;
-    this.#storage = storage;
-    this.#limit = limit;
-    this.#partitionKey = partitionKey;
     assert(limit >= 0);
     assertOrderingIncludesPK(
       input.getSchema().sort,
       input.getSchema().primaryKey
     );
     input.setOutput(this);
+    this.#input = input;
+    this.#storage = storage;
+    this.#limit = limit;
+    this.#partitionKey = partitionKey;
+    this.#partitionKeyComparator = partitionKey && makePartitionKeyComparator(partitionKey);
   }
   setOutput(output) {
     this.#output = output;
@@ -10571,9 +10677,8 @@ var Take = class {
     return this.#input.getSchema();
   }
   *fetch(req) {
-    if (this.#partitionKey === void 0 || req.constraint?.key === this.#partitionKey) {
-      const partitionValue = this.#partitionKey === void 0 ? void 0 : req.constraint?.value;
-      const takeStateKey = getTakeStateKey(partitionValue);
+    if (!this.#partitionKey || req.constraint && constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {
+      const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
       const takeState = this.#storage.get(takeStateKey);
       if (!takeState) {
         yield* this.#initialFetch(req);
@@ -10598,8 +10703,7 @@ var Take = class {
       if (this.getSchema().compareRows(inputNode.row, maxBound) > 0) {
         return;
       }
-      const partitionValue = inputNode.row[this.#partitionKey];
-      const takeStateKey = getTakeStateKey(partitionValue);
+      const takeStateKey = getTakeStateKey(this.#partitionKey, inputNode.row);
       const takeState = this.#storage.get(takeStateKey);
       if (takeState?.bound !== void 0 && this.getSchema().compareRows(takeState.bound, inputNode.row) >= 0) {
         yield inputNode;
@@ -10609,13 +10713,13 @@ var Take = class {
   *#initialFetch(req) {
     assert(req.start === void 0);
     assert(
-      this.#partitionKey === void 0 || req.constraint !== void 0 && req.constraint.key === this.#partitionKey
+      !this.#partitionKey || req.constraint && // TODO: Compound keys
+      constraintMatchesPartitionKey(req.constraint, this.#partitionKey)
     );
     if (this.#limit === 0) {
       return;
     }
-    const partitionValue = this.#partitionKey === void 0 ? void 0 : req.constraint?.value;
-    const takeStateKey = getTakeStateKey(partitionValue);
+    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
     assert(this.#storage.get(takeStateKey) === void 0);
     let size = 0;
     let bound;
@@ -10646,14 +10750,17 @@ var Take = class {
   *cleanup(req) {
     assert(req.start === void 0);
     assert(
-      this.#partitionKey === void 0 || req.constraint !== void 0 && req.constraint.key === this.#partitionKey
+      !this.#partitionKey || req.constraint && // TODO: Compound keys
+      constraintMatchesPartitionKey(req.constraint, this.#partitionKey)
     );
     let takeState;
     if (this.#limit > 0) {
-      const partitionValue = this.#partitionKey === void 0 ? void 0 : req.constraint?.value;
-      const takeStateKey = getTakeStateKey(partitionValue);
+      const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
       takeState = this.#storage.get(takeStateKey);
-      assert(takeState !== void 0);
+      assert(
+        takeState !== void 0,
+        "takeStateKey was: " + takeStateKey + ", partitionKey was: " + this.#partitionKey + ", constraint was: " + JSON.stringify(req.constraint)
+      );
       this.#storage.del(takeStateKey);
     }
     for (const inputNode of this.#input.cleanup(req)) {
@@ -10664,17 +10771,15 @@ var Take = class {
     }
   }
   #getStateAndConstraint(row) {
-    const partitionValue = this.#partitionKey === void 0 ? void 0 : row[this.#partitionKey];
-    const takeStateKey = getTakeStateKey(partitionValue);
+    const takeStateKey = getTakeStateKey(this.#partitionKey, row);
     const takeState = this.#storage.get(takeStateKey);
     let maxBound;
     let constraint;
     if (takeState) {
       maxBound = this.#storage.get(MAX_BOUND_KEY);
-      constraint = this.#partitionKey ? {
-        key: this.#partitionKey,
-        value: partitionValue
-      } : void 0;
+      constraint = this.#partitionKey && Object.fromEntries(
+        this.#partitionKey.map((key) => [key, row[key]])
+      );
     }
     return { takeState, takeStateKey, maxBound, constraint };
   }
@@ -10749,57 +10854,41 @@ var Take = class {
       if (compToBound > 0) {
         return;
       }
-      if (takeState.size === 1) {
-        this.#storage.set(takeStateKey, {
-          size: 0,
-          bound: void 0
-        });
-        this.#output.push(change);
-        return;
-      }
-      let beforeBoundNode;
-      let afterBoundNode;
-      if (compToBound === 0) {
-        [beforeBoundNode, afterBoundNode] = take(
-          this.#input.fetch({
-            start: {
-              row: takeState.bound,
-              basis: "before"
-            },
-            constraint
-          }),
-          2
-        );
-      } else {
-        [beforeBoundNode, , afterBoundNode] = take(
-          this.#input.fetch({
-            start: {
-              row: takeState.bound,
-              basis: "before"
-            },
-            constraint
-          }),
-          3
-        );
+      let newBound;
+      for (const node of this.#input.fetch({
+        start: {
+          row: takeState.bound,
+          basis: "before"
+        },
+        constraint
+      })) {
+        const push2 = compareRows(node.row, takeState.bound) > 0;
+        newBound = {
+          node,
+          push: push2
+        };
+        if (push2) {
+          break;
+        }
       }
-      if (afterBoundNode) {
+      if (newBound?.push) {
         this.#setTakeState(
           takeStateKey,
           takeState.size,
-          afterBoundNode.row,
+          newBound.node.row,
           maxBound
         );
         this.#output.push(change);
         this.#output.push({
           type: "add",
-          node: afterBoundNode
+          node: newBound.node
         });
         return;
       }
       this.#setTakeState(
         takeStateKey,
         takeState.size - 1,
-        compToBound === 0 ? beforeBoundNode.row : takeState.bound,
+        newBound?.node.row,
         maxBound
       );
       this.#output.push(change);
@@ -10811,33 +10900,32 @@ var Take = class {
   }
   #pushEditChange(change) {
     assert(this.#output, "Output not set");
-    if (this.#partitionKey !== void 0 && change.oldRow[this.#partitionKey] !== change.row[this.#partitionKey]) {
+    if (this.#partitionKeyComparator && this.#partitionKeyComparator(change.oldNode.row, change.node.row) !== 0) {
       this.push({
         type: "remove",
-        node: {
-          row: change.oldRow,
-          relationships: {}
-        }
+        node: change.oldNode
       });
       this.push({
         type: "add",
-        node: {
-          row: change.row,
-          relationships: {}
-        }
+        node: change.node
       });
       return;
     }
-    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.oldRow);
+    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.oldNode.row);
     if (!takeState) {
       return;
     }
     assert(takeState.bound, "Bound should be set");
     const { compareRows } = this.getSchema();
-    const oldCmp = compareRows(change.oldRow, takeState.bound);
-    const newCmp = compareRows(change.row, takeState.bound);
+    const oldCmp = compareRows(change.oldNode.row, takeState.bound);
+    const newCmp = compareRows(change.node.row, takeState.bound);
     const replaceBoundAndForwardChange = () => {
-      this.#setTakeState(takeStateKey, takeState.size, change.row, maxBound);
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        change.node.row,
+        maxBound
+      );
       this.#output.push(change);
     };
     if (oldCmp === 0) {
@@ -10882,7 +10970,7 @@ var Take = class {
           })
         )
       );
-      if (compareRows(newBoundNode.row, change.row) === 0) {
+      if (compareRows(newBoundNode.row, change.node.row) === 0) {
         replaceBoundAndForwardChange();
         return;
       }
@@ -10894,10 +10982,7 @@ var Take = class {
       );
       this.#output.push({
         type: "remove",
-        node: {
-          row: change.oldRow,
-          relationships: {}
-        }
+        node: change.oldNode
       });
       this.#output.push({
         type: "add",
@@ -10933,10 +11018,7 @@ var Take = class {
       });
       this.#output.push({
         type: "add",
-        node: {
-          row: change.row,
-          relationships: {}
-        }
+        node: change.node
       });
       return;
     }
@@ -10958,7 +11040,7 @@ var Take = class {
           })
         )
       );
-      if (compareRows(afterBoundNode.row, change.row) === 0) {
+      if (compareRows(afterBoundNode.row, change.node.row) === 0) {
         replaceBoundAndForwardChange();
         return;
       }
@@ -10970,10 +11052,7 @@ var Take = class {
       );
       this.#output.push({
         type: "remove",
-        node: {
-          row: change.oldRow,
-          relationships: {}
-        }
+        node: change.oldNode
       });
       this.#output.push({
         type: "add",
@@ -10996,8 +11075,33 @@ var Take = class {
     this.#input.destroy();
   }
 };
-function getTakeStateKey(partitionValue) {
-  return JSON.stringify(["take", normalizeUndefined(partitionValue)]);
+function getTakeStateKey(partitionKey, rowOrConstraint) {
+  const partitionValues = [];
+  if (partitionKey && rowOrConstraint) {
+    for (const key of partitionKey) {
+      partitionValues.push(rowOrConstraint[key]);
+    }
+  }
+  return JSON.stringify(["take", ...partitionValues]);
+}
+function constraintMatchesPartitionKey(constraint, partitionKey) {
+  for (const key of partitionKey) {
+    if (!hasOwn(constraint, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function makePartitionKeyComparator(partitionKey) {
+  return (a, b) => {
+    for (const key of partitionKey) {
+      const cmp2 = compareValues(a[key], b[key]);
+      if (cmp2 !== 0) {
+        return cmp2;
+      }
+    }
+    return 0;
+  };
 }
 
 // ../zql/src/builder/like.ts
@@ -11050,6 +11154,24 @@ function patternToRegExp(source, flags = "") {
 
 // ../zql/src/builder/filter.ts
 function createPredicate(condition) {
+  if (condition.type !== "simple") {
+    const predicates = condition.conditions.map((c) => createPredicate(c));
+    return condition.type === "and" ? (row) => {
+      for (const predicate of predicates) {
+        if (!predicate(row)) {
+          return false;
+        }
+      }
+      return true;
+    } : (row) => {
+      for (const predicate of predicates) {
+        if (predicate(row)) {
+          return true;
+        }
+      }
+      return false;
+    };
+  }
   const { left } = condition;
   const { right } = condition;
   assert(
@@ -11115,11 +11237,11 @@ function createPredicateImpl(rhs, operator) {
     case "LIKE":
       return getLikePredicate(rhs, "");
     case "NOT LIKE":
-      return not(getLikePredicate(rhs, ""));
+      return not2(getLikePredicate(rhs, ""));
     case "ILIKE":
       return getLikePredicate(rhs, "i");
     case "NOT ILIKE":
-      return not(getLikePredicate(rhs, "i"));
+      return not2(getLikePredicate(rhs, "i"));
     case "IN": {
       assert(Array.isArray(rhs));
       const set = new Set(rhs);
@@ -11135,74 +11257,71 @@ function createPredicateImpl(rhs, operator) {
       throw new Error(`Unexpected operator: ${operator}`);
   }
 }
-function not(f) {
+function not2(f) {
   return (lhs) => !f(lhs);
 }
-
-// ../zql/src/builder/builder.ts
-function buildPipeline(ast, delegate, staticQueryParameters) {
-  return buildPipelineInternal(
-    bindStaticParameters(ast, staticQueryParameters),
-    delegate,
-    staticQueryParameters
-  );
-}
-function bindStaticParameters(ast, staticQueryParameters) {
-  const visit = (node) => {
-    if (node.where) {
-      return {
-        ...node,
-        where: bindCondition(node.where),
-        related: node.related?.map((sq) => ({
-          ...sq,
-          subquery: visit(sq.subquery)
-        }))
-      };
-    }
-    return node;
-  };
-  function bindCondition(condition) {
-    if (condition.type === "simple") {
+function transformFilters(filters) {
+  if (!filters) {
+    return { filters: void 0, conditionsRemoved: false };
+  }
+  switch (filters.type) {
+    case "simple":
+      return { filters, conditionsRemoved: false };
+    case "correlatedSubquery":
+      return { filters: void 0, conditionsRemoved: true };
+    case "and": {
+      const transformedConditions = [];
+      for (const cond of filters.conditions) {
+        assert(cond.type === "simple" || cond.type === "correlatedSubquery");
+        if (cond.type === "simple") {
+          transformedConditions.push(cond);
+        }
+      }
+      const conditionsRemoved = transformedConditions.length !== filters.conditions.length;
+      if (transformedConditions.length === 0) {
+        return { filters: void 0, conditionsRemoved };
+      }
+      if (transformedConditions.length === 1) {
+        return {
+          filters: transformedConditions[0],
+          conditionsRemoved
+        };
+      }
       return {
-        ...condition,
-        left: bindValue(condition.left),
-        right: bindValue(condition.right)
+        filters: {
+          type: "and",
+          conditions: transformedConditions
+        },
+        conditionsRemoved
       };
     }
-    if (condition.type === "correlatedSubquery") {
-      return {
-        ...condition,
-        related: {
-          ...condition.related,
-          subquery: visit(condition.related.subquery)
+    case "or": {
+      const transformedConditions = [];
+      let conditionsRemoved = false;
+      for (const cond of filters.conditions) {
+        assert(cond.type !== "or");
+        const transformed = transformFilters(cond);
+        if (transformed.filters === void 0) {
+          return { filters: void 0, conditionsRemoved: true };
         }
-      };
-    }
-    return {
-      ...condition,
-      conditions: condition.conditions.map(bindCondition)
-    };
-  }
-  const bindValue = (value) => {
-    if (isParameter(value)) {
-      const anchor = must(
-        staticQueryParameters,
-        "Static query params do not exist"
-      )[value.anchor];
-      const resolvedValue = anchor?.[value.field] ?? null;
+        conditionsRemoved = conditionsRemoved || transformed.conditionsRemoved;
+        transformedConditions.push(transformed.filters);
+      }
       return {
-        type: "literal",
-        value: resolvedValue
+        filters: { type: "or", conditions: transformedConditions },
+        conditionsRemoved
       };
     }
-    return value;
-  };
-  return visit(ast);
+    default:
+      unreachable(filters);
+  }
 }
-function isParameter(value) {
-  return value.type === "static";
+
+// ../zql/src/builder/builder.ts
+function buildPipeline(ast, delegate) {
+  return buildPipelineInternal(ast, delegate);
 }
-function buildPipelineInternal(ast, delegate, staticQueryParameters, partitionKey) {
+function buildPipelineInternal(ast, delegate, partitionKey) {
   const source = delegate.getSource(ast.table);
   if (!source) {
     throw new Error(`Source not found: ${ast.table}`);
@@ -11215,17 +11334,22 @@ function buildPipelineInternal(ast, delegate, staticQueryParameters, partitionKe
     end = new Skip(end, ast.start);
   }
   for (const csq of gatherCorrelatedSubqueryQueriesFromCondition(ast.where)) {
-    end = applyCorrelatedSubQuery(csq, delegate, staticQueryParameters, end);
+    end = applyCorrelatedSubQuery(csq, delegate, end);
   }
   if (ast.where) {
     end = applyWhere(end, ast.where, appliedFilters, delegate);
   }
   if (ast.limit) {
-    end = new Take(end, delegate.createStorage(), ast.limit, partitionKey);
+    end = new Take(
+      end,
+      delegate.createStorage(),
+      ast.limit,
+      partitionKey === void 0 ? void 0 : [partitionKey]
+    );
   }
   if (ast.related) {
     for (const csq of ast.related) {
-      end = applyCorrelatedSubQuery(csq, delegate, staticQueryParameters, end);
+      end = applyCorrelatedSubQuery(csq, delegate, end);
     }
   }
   return end;
@@ -11262,20 +11386,20 @@ function applySimpleCondition(input, condition, appliedFilters) {
     createPredicate(condition)
   );
 }
-function applyCorrelatedSubQuery(sq, delegate, staticQueryParameters, end) {
+function applyCorrelatedSubQuery(sq, delegate, end) {
   assert(sq.subquery.alias, "Subquery must have an alias");
   const child = buildPipelineInternal(
     sq.subquery,
     delegate,
-    staticQueryParameters,
     sq.correlation.childField
   );
   end = new Join({
     parent: end,
     child,
     storage: delegate.createStorage(),
-    parentKey: sq.correlation.parentField,
-    childKey: sq.correlation.childField,
+    // TODO: Compound keys in the AST
+    parentKey: [sq.correlation.parentField],
+    childKey: [sq.correlation.childField],
     relationshipName: sq.subquery.alias,
     hidden: sq.hidden ?? false
   });
@@ -11412,196 +11536,44 @@ var ArrayView = class {
   addListener(listener) {
     assert(!this.#listeners.has(listener), "Listener already registered");
     this.#listeners.add(listener);
-    listener(this.data);
-    return () => {
-      this.#listeners.delete(listener);
-    };
-  }
-  #fireListeners() {
-    for (const listener of this.#listeners) {
-      listener(this.data);
-    }
-  }
-  destroy() {
-    this.onDestroy?.();
-  }
-  #hydrate() {
-    this.#dirty = true;
-    for (const node of this.#input.fetch({})) {
-      applyChange(
-        this.#root,
-        { type: "add", node },
-        this.#schema,
-        "",
-        this.#format
-      );
-    }
-    this.flush();
-  }
-  push(change) {
-    this.#dirty = true;
-    applyChange(this.#root, change, this.#schema, "", this.#format);
-  }
-  flush() {
-    if (!this.#dirty) {
-      return;
-    }
-    this.#dirty = false;
-    this.#fireListeners();
-  }
-};
-
-// ../zql/src/query/expression.ts
-var ExpressionBuilder = class {
-  #exists;
-  constructor(exists) {
-    this.#exists = exists;
-    this.exists = this.exists.bind(this);
-  }
-  get eb() {
-    return this;
-  }
-  cmp(field, opOrValue, value) {
-    return cmp(field, opOrValue, value);
-  }
-  cmpLit(left, op, right) {
-    return {
-      type: "simple",
-      left: isParameter2(left) ? left : { type: "literal", value: left },
-      right: isParameter2(right) ? right : { type: "literal", value: right },
-      op
-    };
-  }
-  and = and;
-  or = or;
-  not = not2;
-  exists(relationship, cb) {
-    return this.#exists(relationship, cb);
-  }
-};
-function and(...conditions) {
-  const expressions = filterTrue(filterUndefined(conditions));
-  if (expressions.length === 1) {
-    return expressions[0];
-  }
-  if (expressions.some(isAlwaysFalse)) {
-    return FALSE;
+    listener(this.data);
+    return () => {
+      this.#listeners.delete(listener);
+    };
   }
-  return { type: "and", conditions: expressions };
-}
-function or(...conditions) {
-  const expressions = filterFalse(filterUndefined(conditions));
-  if (expressions.length === 1) {
-    return expressions[0];
+  #fireListeners() {
+    for (const listener of this.#listeners) {
+      listener(this.data);
+    }
   }
-  if (expressions.some(isAlwaysTrue)) {
-    return TRUE;
+  destroy() {
+    this.onDestroy?.();
   }
-  return { type: "or", conditions: expressions };
-}
-function not2(expression) {
-  switch (expression.type) {
-    case "and":
-      return {
-        type: "or",
-        conditions: expression.conditions.map(not2)
-      };
-    case "or":
-      return {
-        type: "and",
-        conditions: expression.conditions.map(not2)
-      };
-    case "correlatedSubquery":
-      return {
-        type: "correlatedSubquery",
-        related: expression.related,
-        op: negateOperator(expression.op)
-      };
-    case "simple":
-      return {
-        type: "simple",
-        op: negateOperator(expression.op),
-        left: expression.left,
-        right: expression.right
-      };
+  #hydrate() {
+    this.#dirty = true;
+    for (const node of this.#input.fetch({})) {
+      applyChange(
+        this.#root,
+        { type: "add", node },
+        this.#schema,
+        "",
+        this.#format
+      );
+    }
+    this.flush();
   }
-}
-function cmp(field, opOrValue, value) {
-  let op;
-  if (value === void 0) {
-    value = opOrValue;
-    op = "=";
-  } else {
-    op = opOrValue;
+  push(change) {
+    this.#dirty = true;
+    applyChange(this.#root, change, this.#schema, "", this.#format);
   }
-  return {
-    type: "simple",
-    left: { type: "column", name: field },
-    right: isParameter2(value) ? value : { type: "literal", value },
-    op
-  };
-}
-function isParameter2(value) {
-  return typeof value === "object" && value?.type === "static";
-}
-var TRUE = {
-  type: "and",
-  conditions: []
-};
-var FALSE = {
-  type: "or",
-  conditions: []
-};
-function isAlwaysTrue(condition) {
-  return condition.type === "and" && condition.conditions.length === 0;
-}
-function isAlwaysFalse(condition) {
-  return condition.type === "or" && condition.conditions.length === 0;
-}
-function flatten(type, conditions) {
-  const flattened2 = [];
-  for (const c of conditions) {
-    if (c.type === type) {
-      flattened2.push(...c.conditions);
-    } else {
-      flattened2.push(c);
+  flush() {
+    if (!this.#dirty) {
+      return;
     }
+    this.#dirty = false;
+    this.#fireListeners();
   }
-  return flattened2;
-}
-var negateSimpleOperatorMap = {
-  ["="]: "!=",
-  ["!="]: "=",
-  ["<"]: ">=",
-  [">"]: "<=",
-  [">="]: "<",
-  ["<="]: ">",
-  ["IN"]: "NOT IN",
-  ["NOT IN"]: "IN",
-  ["LIKE"]: "NOT LIKE",
-  ["NOT LIKE"]: "LIKE",
-  ["ILIKE"]: "NOT ILIKE",
-  ["NOT ILIKE"]: "ILIKE",
-  ["IS"]: "IS NOT",
-  ["IS NOT"]: "IS"
-};
-var negateOperatorMap = {
-  ...negateSimpleOperatorMap,
-  ["EXISTS"]: "NOT EXISTS",
-  ["NOT EXISTS"]: "EXISTS"
 };
-function negateOperator(op) {
-  return must(negateOperatorMap[op]);
-}
-function filterUndefined(array9) {
-  return array9.filter((e) => e !== void 0);
-}
-function filterTrue(conditions) {
-  return conditions.filter((c) => !isAlwaysTrue(c));
-}
-function filterFalse(conditions) {
-  return conditions.filter((c) => !isAlwaysFalse(c));
-}
 
 // ../zql/src/query/dnf.ts
 function dnf(condition) {
@@ -11757,7 +11729,7 @@ var AbstractQuery = class {
     }
     if (isJunctionRelationship(junctionRelationship)) {
       const destSchema = junctionRelationship.dest.schema;
-      const junctionSchema = junctionRelationship.junction.schema;
+      const junctionSchema = junctionRelationship.junction.dest.schema;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -11777,7 +11749,7 @@ var AbstractQuery = class {
             {
               correlation: {
                 parentField: junctionRelationship.source,
-                childField: junctionRelationship.junction.sourceField,
+                childField: junctionRelationship.junction.source,
                 op: "="
               },
               subquery: {
@@ -11787,7 +11759,7 @@ var AbstractQuery = class {
                 related: [
                   {
                     correlation: {
-                      parentField: junctionRelationship.junction.destField,
+                      parentField: junctionRelationship.junction.dest.field,
                       childField: junctionRelationship.dest.field,
                       op: "="
                     },
@@ -11813,7 +11785,7 @@ var AbstractQuery = class {
   where(fieldOrExpressionFactory, opOrValue, value) {
     let cond;
     if (typeof fieldOrExpressionFactory === "function") {
-      cond = fieldOrExpressionFactory(new ExpressionBuilder(this.#exists));
+      cond = fieldOrExpressionFactory(new ExpressionBuilder(this._exists));
     } else {
       assert(opOrValue !== void 0, "Invalid condition");
       cond = cmp(fieldOrExpressionFactory, opOrValue, value);
@@ -11870,7 +11842,7 @@ var AbstractQuery = class {
       this.#format
     );
   }
-  #exists = (relationship, cb = (q) => q) => {
+  _exists = (relationship, cb = (q) => q) => {
     const related = this.#schema.relationships[relationship];
     assert(related, "Invalid relationship");
     const fieldRelationship = related;
@@ -11902,7 +11874,7 @@ var AbstractQuery = class {
     }
     if (isJunctionRelationship(junctionRelationship)) {
       const destSchema = junctionRelationship.dest.schema;
-      const junctionSchema = junctionRelationship.junction.schema;
+      const junctionSchema = junctionRelationship.junction.dest.schema;
       const queryToDest = cb(
         this._newQuery(
           destSchema,
@@ -11918,7 +11890,7 @@ var AbstractQuery = class {
         related: {
           correlation: {
             parentField: junctionRelationship.source,
-            childField: junctionRelationship.junction.sourceField,
+            childField: junctionRelationship.junction.source,
             op: "="
           },
           subquery: {
@@ -11929,7 +11901,7 @@ var AbstractQuery = class {
               type: "correlatedSubquery",
               related: {
                 correlation: {
-                  parentField: junctionRelationship.junction.destField,
+                  parentField: junctionRelationship.junction.dest.field,
                   childField: junctionRelationship.dest.field,
                   op: "="
                 },
@@ -11973,6 +11945,7 @@ var AbstractQuery = class {
   }
 };
 var astForTestingSymbol = Symbol();
+var completedAstSymbol = Symbol();
 var QueryImpl = class extends AbstractQuery {
   #delegate;
   #ast;
@@ -11985,13 +11958,16 @@ var QueryImpl = class extends AbstractQuery {
   get [astForTestingSymbol]() {
     return this.#ast;
   }
+  get [completedAstSymbol]() {
+    return this._completeAst();
+  }
   _newQuery(schema, ast, format) {
     return newQueryWithDetails(this.#delegate, schema, ast, format);
   }
   materialize(factory) {
     const ast = this._completeAst();
     const removeServerQuery = this.#delegate.addServerQuery(ast);
-    const input = buildPipeline(ast, this.#delegate, void 0);
+    const input = buildPipeline(ast, this.#delegate);
     let removeCommitObserver;
     const onDestroy = () => {
       input.destroy();
@@ -12060,6 +12036,9 @@ var AuthQuery = class _AuthQuery extends AbstractQuery {
   constructor(schema, ast = { table: schema.tableName }, format) {
     super(schema, ast, format);
   }
+  expressionBuilder() {
+    return new ExpressionBuilder(this._exists);
+  }
   _newQuery(schema, ast, format) {
     return new _AuthQuery(schema, ast, format);
   }
@@ -12080,62 +12059,74 @@ var AuthQuery = class _AuthQuery extends AbstractQuery {
 // ../zero-schema/src/authorization.ts
 async function defineAuthorization(schema, definer) {
   const normalizedSchema = normalizeSchema(schema);
-  const queries = {};
+  const expressionBuilders = {};
   for (const [name, tableSchema] of Object.entries(normalizedSchema.tables)) {
-    queries[name] = new AuthQuery(tableSchema);
+    expressionBuilders[name] = new AuthQuery(tableSchema).expressionBuilder();
   }
-  const config = await definer(queries);
-  return compileAuthorization(config);
+  const config = await definer();
+  return compileAuthorization(config, expressionBuilders);
 }
-function compileAuthorization(authz) {
+function compileAuthorization(authz, expressionBuilders) {
   if (!authz) {
     return void 0;
   }
   const ret = {};
   for (const [tableName, tableConfig] of Object.entries(authz)) {
     ret[tableName] = {
-      row: compileRowConfig(tableConfig.row),
-      cell: compileCellConfig(tableConfig.cell)
+      row: compileRowConfig(tableConfig.row, expressionBuilders[tableName]),
+      cell: compileCellConfig(tableConfig.cell, expressionBuilders[tableName])
     };
   }
   return ret;
 }
-function compileRowConfig(rowRules) {
+function compileRowConfig(rowRules, expressionBuilder) {
   if (!rowRules) {
     return void 0;
   }
   return {
-    select: compileRules(rowRules.select),
-    insert: compileRules(rowRules.insert),
-    update: compileRules(rowRules.update),
-    delete: compileRules(rowRules.delete)
+    select: compileRules(rowRules.select, expressionBuilder),
+    insert: compileRules(rowRules.insert, expressionBuilder),
+    update: {
+      preMutation: compileRules(
+        rowRules.update?.preMutation,
+        expressionBuilder
+      ),
+      postProposedMutation: compileRules(
+        rowRules.update?.postProposedMutation,
+        expressionBuilder
+      )
+    },
+    delete: compileRules(rowRules.delete, expressionBuilder)
   };
 }
-function compileRules(rules) {
+function compileRules(rules, expressionBuilder) {
   if (!rules) {
     return void 0;
   }
   return rules.map(
     (rule) => [
       "allow",
-      rule(
-        authDataRef,
-        preMutationRowRef
-      ).ast
+      rule(authDataRef, expressionBuilder)
     ]
   );
 }
-function compileCellConfig(cellRules) {
+function compileCellConfig(cellRules, expressionBuilder) {
   if (!cellRules) {
     return void 0;
   }
   const ret = {};
   for (const [columnName, rules] of Object.entries(cellRules)) {
     ret[columnName] = {
-      select: compileRules(rules.select),
-      insert: compileRules(rules.insert),
-      update: compileRules(rules.update),
-      delete: compileRules(rules.delete)
+      select: compileRules(rules.select, expressionBuilder),
+      insert: compileRules(rules.insert, expressionBuilder),
+      update: {
+        preMutation: compileRules(rules.update?.preMutation, expressionBuilder),
+        postProposedMutation: compileRules(
+          rules.update?.postProposedMutation,
+          expressionBuilder
+        )
+      },
+      delete: compileRules(rules.delete, expressionBuilder)
     };
   }
   return ret;
@@ -12168,7 +12159,7 @@ function escapeLike(val) {
 }
 
 // ../zero-client/src/client/zero.ts
-import { LogContext as LogContext3 } from "@rocicorp/logger";
+import { LogContext as LogContext4 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
 
 // ../zero-protocol/src/queries-patch.ts
@@ -12312,10 +12303,14 @@ var pokeStartBodySchema = valita_exports.object({
   // able to send a base cookie with value `null` to match that state.
   baseCookie: nullableVersionSchema,
   cookie: versionSchema,
+  /**
+   * This field is always set if the poke contains a `rowsPatch`.
+   * It may be absent for patches that only update clients and queries.
+   */
   schemaVersions: valita_exports.object({
     minSupportedVersion: valita_exports.number(),
     maxSupportedVersion: valita_exports.number()
-  }),
+  }).optional(),
   timestamp: valita_exports.number().optional()
 });
 var pokePartBodySchema = valita_exports.object({
@@ -14117,6 +14112,29 @@ var EmptyBTree = (() => {
   return t2;
 })();
 
+// ../zql/src/ivm/constraint.ts
+function constraintMatchesRow(constraint, row) {
+  for (const [key, value] of Object.entries(constraint)) {
+    if (!valuesEqual(row[key], value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function constraintMatchesPrimaryKey(constraint, primary) {
+  const constraintKeys = Object.keys(constraint);
+  if (constraintKeys.length !== primary.length) {
+    return false;
+  }
+  constraintKeys.sort(stringCompare);
+  for (let i = 0; i < constraintKeys.length; i++) {
+    if (constraintKeys[i][0] !== primary[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // ../zql/src/ivm/lookahead-iterator.ts
 var LookaheadIterator = class {
   #iter;
@@ -14200,8 +14218,7 @@ var MemorySource = class {
     };
   }
   connect(sort, optionalFilters) {
-    const filteredOptionalFilters = filterOptionalFilters(optionalFilters);
-    const predicates = filteredOptionalFilters.filters.map((c) => createPredicate(c));
+    const transformedFilters = transformFilters(optionalFilters);
     const input = {
       getSchema: () => schema,
       fetch: (req) => this.#fetch(req, connection),
@@ -14212,14 +14229,17 @@ var MemorySource = class {
       destroy: () => {
         this.#disconnect(input);
       },
-      appliedFilters: filteredOptionalFilters.allApplied
+      appliedFilters: !transformedFilters.conditionsRemoved
     };
     const connection = {
       input,
       output: void 0,
       sort,
       compareRows: makeComparator(sort),
-      optionalFilters: predicates
+      filters: transformedFilters.filters ? {
+        condition: transformedFilters.filters,
+        predicate: createPredicate(transformedFilters.filters)
+      } : void 0
     };
     const schema = this.#getSchema(connection);
     assertOrderingIncludesPK(sort, this.#primaryKey);
@@ -14275,9 +14295,11 @@ var MemorySource = class {
     const { sort: requestedSort } = conn;
     const indexSort = [];
     if (req.constraint) {
-      indexSort.push([req.constraint.key, "asc"]);
+      for (const key of Object.keys(req.constraint)) {
+        indexSort.push([key, "asc"]);
+      }
     }
-    if (this.#primaryKey.length > 1 || req.constraint?.key !== this.#primaryKey[0]) {
+    if (this.#primaryKey.length > 1 || !req.constraint || !constraintMatchesPrimaryKey(req.constraint, this.#primaryKey)) {
       indexSort.push(...requestedSort);
     }
     const index = this.#getOrCreateIndex(indexSort, from);
@@ -14287,20 +14309,10 @@ var MemorySource = class {
         overlay = this.#overlay;
       }
     }
-    const matchesConstraint = (row) => {
-      if (!req.constraint) {
-        return true;
-      }
-      const { key, value } = req.constraint;
-      return valuesEqual(row[key], value);
-    };
-    const matchesFilters = (row) => conn.optionalFilters.every((f) => f(row));
-    const matchesConstraintAndFilters = (row) => matchesConstraint(row) && matchesFilters(row);
-    if (overlay) {
-      if (!matchesConstraintAndFilters(overlay.change.row)) {
-        overlay = void 0;
-      }
-    }
+    const { constraint } = req;
+    const matchesConstraint = constraint ? (row) => constraintMatchesRow(constraint, row) : (_) => true;
+    const predicate = conn.filters?.predicate;
+    const matchesConstraintAndFilters = predicate ? (row) => matchesConstraint(row) && predicate(row) : matchesConstraint;
     const nextLowerKey = (row) => {
       if (!row) {
         return void 0;
@@ -14325,9 +14337,7 @@ var MemorySource = class {
     let startAt = req.start?.row;
     if (startAt) {
       if (req.constraint) {
-        if (!matchesConstraint(startAt)) {
-          assert(false, "Start row must match constraint");
-        }
+        assert(matchesConstraint(startAt), "Start row must match constraint");
       }
       if (req.start.basis === "before") {
         startAt = nextLowerKey(startAt);
@@ -14337,8 +14347,8 @@ var MemorySource = class {
     if (req.constraint) {
       scanStart = {};
       for (const [key, dir] of indexSort) {
-        if (key === req.constraint.key) {
-          scanStart[key] = req.constraint.value;
+        if (hasOwn(req.constraint, key)) {
+          scanStart[key] = req.constraint[key];
         } else {
           scanStart[key] = dir === "asc" ? minValue : maxValue;
         }
@@ -14353,13 +14363,14 @@ var MemorySource = class {
       data.keys(scanStart),
       req.constraint,
       overlay,
-      comparator
+      comparator,
+      conn.filters?.predicate
     );
     const withConstraint = generateWithConstraint(
       generateWithStart(withOverlay, req, comparator),
       req.constraint
     );
-    yield* conn.optionalFilters.length ? generateWithFilter(withConstraint, matchesFilters) : withConstraint;
+    yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
   }
   #cleanup(req, connection) {
     return this.#fetch(req, connection);
@@ -14386,7 +14397,17 @@ var MemorySource = class {
       default:
         unreachable(change);
     }
-    const outputChange = change.type === "edit" ? 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,
@@ -14426,7 +14447,7 @@ var MemorySource = class {
 };
 function* generateWithConstraint(it, constraint) {
   for (const node of it) {
-    if (constraint && !valuesEqual(node.row[constraint.key], constraint.value)) {
+    if (constraint && !constraintMatchesRow(constraint, node.row)) {
       break;
     }
     yield node;
@@ -14464,11 +14485,17 @@ function* generateWithStart(it, req, compare) {
     }
   }
 }
-function* generateWithOverlay(startAt, rows, constraint, overlay, compare) {
-  const overlays = computeOverlays(startAt, constraint, overlay, compare);
+function* generateWithOverlay(startAt, rows, constraint, overlay, compare, filterPredicate) {
+  const overlays = computeOverlays(
+    startAt,
+    constraint,
+    overlay,
+    compare,
+    filterPredicate
+  );
   yield* generateWithOverlayInner(rows, overlays, compare);
 }
-function computeOverlays(startAt, constraint, overlay, compare) {
+function computeOverlays(startAt, constraint, overlay, compare, filterPredicate) {
   let overlays = {
     add: void 0,
     remove: void 0
@@ -14499,6 +14526,9 @@ function computeOverlays(startAt, constraint, overlay, compare) {
   if (constraint) {
     overlays = overlaysForConstraint(overlays, constraint);
   }
+  if (filterPredicate) {
+    overlays = overlaysForFilterPredicate(overlays, filterPredicate);
+  }
   return overlays;
 }
 function overlaysForStartAt({ add, remove }, startAt, compare) {
@@ -14509,12 +14539,19 @@ function overlaysForStartAt({ add, remove }, startAt, compare) {
   };
 }
 function overlaysForConstraint({ add, remove }, constraint) {
-  const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !valuesEqual(row[constraint.key], constraint.value) ? void 0 : row;
+  const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !constraintMatchesRow(constraint, row) ? void 0 : row;
   return {
     add: undefinedIfDoesntMatchConstraint(add),
     remove: undefinedIfDoesntMatchConstraint(remove)
   };
 }
+function overlaysForFilterPredicate({ add, remove }, filterPredicate) {
+  const undefinedIfDoesntMatchFilter = (row) => row === void 0 || !filterPredicate(row) ? void 0 : row;
+  return {
+    add: undefinedIfDoesntMatchFilter(add),
+    remove: undefinedIfDoesntMatchFilter(remove)
+  };
+}
 function* generateWithOverlayInner(rowIterator, overlays, compare) {
   let addOverlayYielded = false;
   let removeOverlaySkipped = false;
@@ -14571,33 +14608,6 @@ function compareBounds(a, b) {
   }
   return compareValues(a, b);
 }
-function filterOptionalFilters(optionalFilters) {
-  if (optionalFilters) {
-    if (optionalFilters.type === "or" && optionalFilters.conditions.length === 1) {
-      optionalFilters = optionalFilters.conditions[0];
-    }
-    if (optionalFilters.type === "and") {
-      const filters = optionalFilters.conditions.filter(
-        (c) => c.type === "simple"
-      );
-      return {
-        filters,
-        allApplied: filters.length === optionalFilters.conditions.length
-      };
-    }
-    if (optionalFilters.type === "simple") {
-      return {
-        filters: [optionalFilters],
-        allApplied: true
-      };
-    }
-    return { filters: [], allApplied: false };
-  }
-  return {
-    filters: [],
-    allApplied: true
-  };
-}
 
 // ../zql/src/ivm/memory-storage.ts
 var MemoryStorage = class {
@@ -15236,7 +15246,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.6.2024112102+391068";
+var version2 = "0.7.2024112700+dfe437";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -15522,6 +15532,9 @@ var State = class {
   }
 };
 
+// ../zero-client/src/client/protocol-version.ts
+var PROTOCOL_VERSION = 1;
+
 // ../zero-client/src/client/query-manager.ts
 var QueryManager = class {
   #clientID;
@@ -15660,24 +15673,90 @@ var QueryManager = class {
 };
 
 // ../zero-client/src/client/reload-error-handler.ts
+import "@rocicorp/logger";
 var RELOAD_REASON_STORAGE_KEY = "_zeroReloadReason";
+var RELOAD_BACKOFF_STATE_KEY = "_zeroReloadBackoffState";
+var backoffStateSchema = valita_exports.object({
+  lastReloadTime: valita_exports.number().default(0),
+  nextIntervalMs: valita_exports.number().default(0)
+});
+var MIN_RELOAD_INTERVAL_MS = 500;
+var MAX_RELOAD_INTERVAL_MS = 6e4;
+var FALLBACK_RELOAD_INTERVAL_MS = 1e4;
+var reloadTimer = null;
 function reloadWithReason(lc, reload2, reason) {
-  if (typeof localStorage === "undefined") {
-    lc.error?.("Zero reloaded the page.", reason);
-  } else {
-    localStorage[RELOAD_REASON_STORAGE_KEY] = reason;
+  if (reloadTimer) {
+    lc.warn?.("reload timer already scheduled");
+    return;
   }
-  reload2();
+  const now = Date.now();
+  const backoff = nextBackoff(lc, now);
+  if (typeof sessionStorage !== "undefined") {
+    sessionStorage.setItem(RELOAD_BACKOFF_STATE_KEY, JSON.stringify(backoff));
+    sessionStorage.setItem(RELOAD_REASON_STORAGE_KEY, reason);
+  }
+  const delay = backoff.lastReloadTime - now;
+  lc.error?.(
+    reason,
+    "\n",
+    "reloading",
+    delay > 0 ? `in ${delay / 1e3} seconds` : ""
+  );
+  reloadTimer = setTimeout(() => {
+    reloadTimer = null;
+    reload2();
+  }, delay);
 }
 function reportReloadReason(lc) {
-  if (typeof localStorage === "undefined") {
-    return;
+  if (typeof sessionStorage !== "undefined") {
+    const reason = sessionStorage.getItem(RELOAD_REASON_STORAGE_KEY);
+    if (reason) {
+      sessionStorage.removeItem(RELOAD_REASON_STORAGE_KEY);
+      lc.error?.("Zero reloaded the page.", reason);
+    }
+  }
+}
+function reloadScheduled() {
+  return reloadTimer !== null;
+}
+function resetBackoff() {
+  if (typeof sessionStorage !== "undefined") {
+    sessionStorage.removeItem(RELOAD_BACKOFF_STATE_KEY);
+  }
+}
+function nextBackoff(lc, now) {
+  if (typeof sessionStorage === "undefined") {
+    lc.warn?.(
+      `sessionStorage not supported. backing off in ${FALLBACK_RELOAD_INTERVAL_MS / 1e3} seconds`
+    );
+    return {
+      lastReloadTime: now + FALLBACK_RELOAD_INTERVAL_MS,
+      nextIntervalMs: MIN_RELOAD_INTERVAL_MS
+    };
   }
-  const reason = localStorage[RELOAD_REASON_STORAGE_KEY];
-  if (reason) {
-    delete localStorage[RELOAD_REASON_STORAGE_KEY];
-    lc.error?.("Zero reloaded the page.", reason);
+  const val = sessionStorage.getItem(RELOAD_BACKOFF_STATE_KEY);
+  if (!val) {
+    return { lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS };
   }
+  let parsed;
+  try {
+    parsed = parse(JSON.parse(val), backoffStateSchema, "passthrough");
+  } catch (e) {
+    lc.warn?.("ignoring unparsable backoff state", val, e);
+    return { lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS };
+  }
+  const { lastReloadTime, nextIntervalMs } = parsed;
+  if (now - lastReloadTime > MAX_RELOAD_INTERVAL_MS * 2) {
+    return { lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS };
+  }
+  if (now < lastReloadTime) {
+    return parsed;
+  }
+  const nextReloadTime = Math.max(now, lastReloadTime + nextIntervalMs);
+  return {
+    lastReloadTime: nextReloadTime,
+    nextIntervalMs: Math.min(nextIntervalMs * 2, MAX_RELOAD_INTERVAL_MS)
+  };
 }
 
 // ../zero-client/src/client/server-error.ts
@@ -16028,9 +16107,6 @@ function rafFallback(callback) {
   setTimeout(callback, 0);
 }
 
-// ../zero-client/src/client/protocol-version.ts
-var PROTOCOL_VERSION = 1;
-
 // ../zero-client/src/client/zero.ts
 var onSetConnectionStateSymbol = Symbol();
 var exposedToTestingSymbol = Symbol();
@@ -16097,14 +16173,9 @@ var Zero = class {
   #lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
   #onPong = () => void 0;
   #online = false;
-  /**
-   * `onOnlineChange` is called when the Zero instance's online status
-   * changes.
-   */
-  onOnlineChange = null;
-  #onUpdateNeeded = null;
-  #onClientStateNotFound = null;
-  #jurisdiction;
+  #onOnlineChange;
+  #onUpdateNeeded;
+  #onClientStateNotFound;
   // Last cookie used to initiate a connection
   #connectCookie = null;
   // Total number of sockets successfully connected by this client
@@ -16118,52 +16189,6 @@ var Zero = class {
   #abortPingTimeout = () => {
   };
   #zeroContext;
-  /**
-   * `onUpdateNeeded` is called when a code update is needed.
-   *
-   * A code update can be needed because:
-   * - the server no longer supports the protocol version of the current code,
-   * - a new Zero client has created a new client group, because its code
-   *   has different mutators, indexes, schema version and/or format version
-   *   from this Zero client. This is likely due to the new client having
-   *   newer code. A code update is needed to be able to locally sync with this
-   *   new Zero client (i.e. to sync while offline, the clients can can
-   *   still sync with each other via the server).
-   *
-   * The default behavior is to reload the page (using `location.reload()`). Set
-   * this to `null` or provide your own function to prevent the page from
-   * reloading automatically. You may want to provide your own function to
-   * display a toast to inform the end user there is a new version of your app
-   * available and prompting them to refresh.
-   */
-  get onUpdateNeeded() {
-    return this.#onUpdateNeeded;
-  }
-  set onUpdateNeeded(callback) {
-    this.#onUpdateNeeded = callback;
-    this.#rep.onUpdateNeeded = callback && ((reason) => {
-      callback(convertOnUpdateNeededReason(reason));
-    });
-  }
-  /**
-   * `onClientStateNotFound` is called when this client will no longer be able
-   * to sync due to missing synchronization state.  This can be because:
-   * - the local persistent synchronization state has been garbage collected.
-   *   This can happen if the client has no pending mutations and has not been
-   *   used for a while.
-   * - the zero-cache fails to find the synchronization state of this client.
-   *
-   * The default behavior is to reload the page (using `location.reload()`). Set
-   * this to `null` or provide your own function to prevent the page from
-   * reloading automatically.
-   */
-  get onClientStateNotFound() {
-    return this.#onClientStateNotFound;
-  }
-  set onClientStateNotFound(value) {
-    this.#onClientStateNotFound = value;
-    this.#rep.onClientStateNotFound = value;
-  }
   #connectResolver = resolver8();
   #pendingPullsByRequestID = /* @__PURE__ */ new Map();
   #lastMutationIDReceived = 0;
@@ -16214,7 +16239,8 @@ var Zero = class {
     const {
       userID,
       onOnlineChange,
-      jurisdiction,
+      onUpdateNeeded,
+      onClientStateNotFound,
       hiddenTabDisconnectDelay = DEFAULT_DISCONNECT_HIDDEN_DELAY_MS,
       kvStore = "idb",
       schema,
@@ -16229,15 +16255,12 @@ var Zero = class {
       false
       // Reenable analytics
     );
-    if (jurisdiction !== void 0 && jurisdiction !== "eu") {
-      throw new Error('ZeroOptions.jurisdiction must be "eu" if present.');
-    }
     if (hiddenTabDisconnectDelay < 0) {
       throw new Error(
         "ZeroOptions.hiddenTabDisconnectDelay must not be negative."
       );
     }
-    this.onOnlineChange = onOnlineChange;
+    this.#onOnlineChange = onOnlineChange;
     this.#options = options;
     this.#logOptions = this.#createLogOptions({
       consoleLogLevel: options.logLevel ?? "error",
@@ -16267,36 +16290,41 @@ var Zero = class {
       kvStore
     };
     const replicacheImplOptions = {
-      enableClientGroupForking: false
+      enableClientGroupForking: false,
+      enableMutationRecovery: false
     };
     const rep = new ReplicacheImpl(replicacheOptions, replicacheImplOptions);
     this.#rep = rep;
     if (false) {
       internalReplicacheImplMap.set(this, rep);
     }
-    rep.getAuth = this.#getAuthToken;
     this.#server = server;
     this.userID = userID;
-    this.#jurisdiction = jurisdiction;
-    this.#lc = new LogContext3(
+    this.#lc = new LogContext4(
       logOptions.logLevel,
       { clientID: rep.clientID },
       logOptions.logSink
     );
-    this.onUpdateNeeded = (reason, serverErrorMsg) => {
+    const onUpdateNeededCallback = onUpdateNeeded ?? ((reason, serverErrorMsg) => {
       reloadWithReason(
         this.#lc,
         this.#reload,
         updateNeededReloadReason(reason, serverErrorMsg)
       );
+    });
+    this.#onUpdateNeeded = onUpdateNeededCallback;
+    this.#rep.onUpdateNeeded = (reason) => {
+      onUpdateNeededCallback(convertOnUpdateNeededReason(reason));
     };
-    this.onClientStateNotFound = (reason) => {
+    const onClientStateNotFoundCallback = onClientStateNotFound ?? ((reason) => {
       reloadWithReason(
         this.#lc,
         this.#reload,
         reason ?? ON_CLIENT_STATE_NOT_FOUND_REASON_CLIENT
       );
-    };
+    });
+    this.#onClientStateNotFound = onClientStateNotFoundCallback;
+    this.#rep.onClientStateNotFound = onClientStateNotFoundCallback;
     const { mutate, mutateBatch } = makeCRUDMutate(
       normalizedSchema,
       rep.mutate
@@ -16433,10 +16461,10 @@ var Zero = class {
    */
   mutateBatch;
   /**
-   * Whether this Zero instance has been closed. Once a Zero instance has
-   * been closed it no longer syncs and you can no longer read or write data out
-   * of it. After it has been closed it is pretty much useless and should not be
-   * used any more.
+   * Whether this Zero instance has been closed.
+   *
+   * Once a Zero instance has been closed it no longer syncs, you can no
+   * longer query or mutate data with it, and its query views stop updating.
    */
   get closed() {
     return this.#rep.closed;
@@ -16444,7 +16472,8 @@ var Zero = class {
   /**
    * Closes this Zero instance.
    *
-   * When closed all subscriptions end and no more read or writes are allowed.
+   * Once a Zero instance has been closed it no longer syncs, you can no
+   * longer query or mutate data with it, and its query views stop updating.
    */
   close() {
     const lc = this.#lc.withContext("close");
@@ -16681,7 +16710,6 @@ var Zero = class {
       this.#options.schema.version,
       this.userID,
       this.#rep.auth,
-      this.#jurisdiction,
       this.#lastMutationIDReceived,
       wsid,
       this.#options.logLevel === "debug",
@@ -16768,6 +16796,7 @@ var Zero = class {
     this.#pokeHandler.handleDisconnect();
   }
   async #handlePokeStart(_lc, pokeMessage) {
+    resetBackoff();
     this.#abortPingTimeout();
     await this.#pokeHandler.handlePokeStart(pokeMessage[1]);
   }
@@ -16869,12 +16898,9 @@ var Zero = class {
       }
     };
   }
-  #getAuthToken = () => {
-    const { auth } = this.#options;
-    return typeof auth === "function" ? auth() : auth;
-  };
-  async #updateAuthToken(lc) {
-    const auth = await this.#getAuthToken();
+  async #updateAuthToken(lc, error) {
+    const { auth: authOption } = this.#options;
+    const auth = await (typeof authOption === "function" ? authOption(error) : authOption);
     if (auth) {
       lc.debug?.("Got auth token");
       this.#rep.auth = auth;
@@ -16910,7 +16936,10 @@ var Zero = class {
             }
             await this.#visibilityWatcher.waitForVisible();
             if (needsReauth) {
-              await this.#updateAuthToken(lc);
+              await this.#updateAuthToken(lc, "invalid-token");
+            }
+            if (reloadScheduled()) {
+              break;
             }
             await this.#connect(lc);
             if (this.closed) {
@@ -17080,7 +17109,7 @@ var Zero = class {
       return;
     }
     this.#online = online;
-    this.onOnlineChange?.(online);
+    this.#onOnlineChange?.(online);
   }
   /**
    * A rough heuristic for whether the client is currently online and
@@ -17138,7 +17167,7 @@ var Zero = class {
     return rv;
   }
 };
-async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, jurisdiction, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8) {
+async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8) {
   const url = new URL(
     appendPath(socketOrigin, `/sync/v${PROTOCOL_VERSION}/connect`)
   );
@@ -17147,9 +17176,6 @@ async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientI
   searchParams.set("clientGroupID", clientGroupID);
   searchParams.set("schemaVersion", schemaVersion.toString());
   searchParams.set("userID", userID);
-  if (jurisdiction !== void 0) {
-    searchParams.set("jurisdiction", jurisdiction);
-  }
   searchParams.set("baseCookie", baseCookie === null ? "" : String(baseCookie));
   searchParams.set("ts", String(performance.now()));
   searchParams.set("lmid", String(lmid));
@@ -17210,4 +17236,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-QB7G63C6.js.map
+//# sourceMappingURL=chunk-HDEKBM3G.js.map