@rocicorp/zero 0.24.2025092500 → 0.24.2025093000

package/out/{chunk-QZPMFA73.js → chunk-YXYKEMHQ.js}

@@ -532,6 +532,38 @@ var IterWrapper = class _IterWrapper {
 function wrapIterable(iter) {
   return new IterWrapper(iter);
 }
+function* mergeIterables(iterables, comparator, distinct = false) {
+  const iterators = iterables.map((i) => i[Symbol.iterator]());
+  try {
+    const current = iterators.map((i) => i.next());
+    let lastYielded;
+    while (current.some((c) => !c.done)) {
+      const min = current.reduce(
+        (acc, c, i) => {
+          if (c.done) {
+            return acc;
+          }
+          if (acc === void 0 || comparator(c.value, acc[0]) < 0) {
+            return [c.value, i];
+          }
+          return acc;
+        },
+        void 0
+      );
+      assert(min !== void 0, "min is undefined");
+      current[min[1]] = iterators[min[1]].next();
+      if (lastYielded !== void 0 && distinct && comparator(lastYielded, min[0]) === 0) {
+        continue;
+      }
+      lastYielded = min[0];
+      yield min[0];
+    }
+  } finally {
+    for (const it of iterators) {
+      it.return?.();
+    }
+  }
+}
 
 // ../replicache/src/btree/node.ts
 var NODE_LEVEL = 0;
@@ -3429,7 +3461,8 @@ var correlatedSubqueryConditionOperatorSchema = literalUnion("EXISTS", "NOT EXIS
 var correlatedSubqueryConditionSchema = readonlyObject({
   type: valita_exports.literal("correlatedSubquery"),
   related: valita_exports.lazy(() => correlatedSubquerySchema),
-  op: correlatedSubqueryConditionOperatorSchema
+  op: correlatedSubqueryConditionOperatorSchema,
+  flip: valita_exports.boolean().optional()
 });
 var conditionSchema = valita_exports.union(
   simpleConditionSchema,
@@ -3459,8 +3492,7 @@ var correlationSchema = readonlyObject({
 var correlatedSubquerySchemaOmitSubquery = readonlyObject({
   correlation: correlationSchema,
   hidden: valita_exports.boolean().optional(),
-  system: literalUnion("permissions", "client", "test").optional(),
-  flip: valita_exports.boolean().optional()
+  system: literalUnion("permissions", "client", "test").optional()
 });
 var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
   subquery: valita_exports.lazy(() => astSchema)
@@ -3500,8 +3532,7 @@ function transformAST(ast, transform) {
           },
           hidden: r.hidden,
           subquery: transformAST(r.subquery, transform),
-          system: r.system,
-          flip: r.flip
+          system: r.system
         })
       )
     ) : void 0,
@@ -4180,7 +4211,7 @@ var Inspector = class {
       },
       rep,
       getSocket,
-      lazy: import("./lazy-inspector-TOTYUTBC.js")
+      lazy: import("./lazy-inspector-A5VQLZYJ.js")
     };
     this.client = new Client(this.#delegate, rep.clientID, rep.clientGroupID);
     this.clientGroup = this.client.clientGroup;
@@ -4334,7 +4365,7 @@ var FilterStart = class {
     return this.#input.getSchema();
   }
   push(change) {
-    this.#output.push(change);
+    this.#output.push(change, this);
   }
   *fetch(req) {
     for (const node of this.#input.fetch(req)) {
@@ -4385,7 +4416,7 @@ var FilterEnd = class {
     return this.#input.getSchema();
   }
   push(change) {
-    this.#output.push(change);
+    this.#output.push(change, this);
   }
 };
 function buildFilterPipeline(input, delegate, pipeline) {
@@ -4512,21 +4543,27 @@ var Exists = class {
               }
               if (size === 1) {
                 if (this.#not) {
-                  this.#output.push({
-                    type: "remove",
-                    node: {
-                      row: change.node.row,
-                      relationships: {
-                        ...change.node.relationships,
-                        [this.#relationshipName]: () => []
+                  this.#output.push(
+                    {
+                      type: "remove",
+                      node: {
+                        row: change.node.row,
+                        relationships: {
+                          ...change.node.relationships,
+                          [this.#relationshipName]: () => []
+                        }
                       }
-                    }
-                  });
+                    },
+                    this
+                  );
                 } else {
-                  this.#output.push({
-                    type: "add",
-                    node: change.node
-                  });
+                  this.#output.push(
+                    {
+                      type: "add",
+                      node: change.node
+                    },
+                    this
+                  );
                 }
               } else {
                 this.#pushWithFilter(change, size);
@@ -4544,23 +4581,29 @@ var Exists = class {
               }
               if (size === 0) {
                 if (this.#not) {
-                  this.#output.push({
-                    type: "add",
-                    node: change.node
-                  });
+                  this.#output.push(
+                    {
+                      type: "add",
+                      node: change.node
+                    },
+                    this
+                  );
                 } else {
-                  this.#output.push({
-                    type: "remove",
-                    node: {
-                      row: change.node.row,
-                      relationships: {
-                        ...change.node.relationships,
-                        [this.#relationshipName]: () => [
-                          change.child.change.node
-                        ]
+                  this.#output.push(
+                    {
+                      type: "remove",
+                      node: {
+                        row: change.node.row,
+                        relationships: {
+                          ...change.node.relationships,
+                          [this.#relationshipName]: () => [
+                            change.child.change.node
+                          ]
+                        }
                       }
-                    }
-                  });
+                    },
+                    this
+                  );
                 }
               } else {
                 this.#pushWithFilter(change, size);
@@ -4594,7 +4637,7 @@ var Exists = class {
    */
   #pushWithFilter(change, size) {
     if (this.#filter(change.node, size)) {
-      this.#output.push(change);
+      this.#output.push(change, this);
     }
   }
   #getSize(node) {
@@ -4652,7 +4695,7 @@ var Exists = class {
 };
 
 // ../zql/src/ivm/push-accumulated.ts
-function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mergeRelationships, addEmptyRelationships) {
+function pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChangeType, mergeRelationships2, addEmptyRelationships) {
   if (accumulatedPushes.length === 0) {
     return;
   }
@@ -4667,7 +4710,7 @@ function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mer
     const existing = candidatesToPush.get(change.type);
     let mergedChange = change;
     if (existing) {
-      mergedChange = mergeRelationships(existing, change);
+      mergedChange = mergeRelationships2(existing, change);
     }
     candidatesToPush.set(change.type, mergedChange);
   }
@@ -4679,14 +4722,20 @@ function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mer
         types.length === 1 && types[0] === "remove",
         "Fan-in:remove expected all removes"
       );
-      output.push(addEmptyRelationships(must(candidatesToPush.get("remove"))));
+      output.push(
+        addEmptyRelationships(must(candidatesToPush.get("remove"))),
+        pusher
+      );
       return;
     case "add":
       assert(
         types.length === 1 && types[0] === "add",
         "Fan-in:add expected all adds"
       );
-      output.push(addEmptyRelationships(must(candidatesToPush.get("add"))));
+      output.push(
+        addEmptyRelationships(must(candidatesToPush.get("add"))),
+        pusher
+      );
       return;
     case "edit": {
       assert(
@@ -4700,12 +4749,12 @@ function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mer
       let editChange = candidatesToPush.get("edit");
       if (editChange) {
         if (addChange) {
-          editChange = mergeRelationships(editChange, addChange);
+          editChange = mergeRelationships2(editChange, addChange);
         }
         if (removeChange) {
-          editChange = mergeRelationships(editChange, removeChange);
+          editChange = mergeRelationships2(editChange, removeChange);
         }
-        output.push(addEmptyRelationships(editChange));
+        output.push(addEmptyRelationships(editChange), pusher);
         return;
       }
       if (addChange && removeChange) {
@@ -4714,11 +4763,15 @@ function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mer
             type: "edit",
             node: addChange.node,
             oldNode: removeChange.node
-          })
+          }),
+          pusher
         );
         return;
       }
-      output.push(addEmptyRelationships(must(addChange ?? removeChange)));
+      output.push(
+        addEmptyRelationships(must(addChange ?? removeChange)),
+        pusher
+      );
       return;
     }
     case "child": {
@@ -4737,7 +4790,7 @@ function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mer
       );
       const childChange = candidatesToPush.get("child");
       if (childChange) {
-        output.push(childChange);
+        output.push(childChange, pusher);
         return;
       }
       const addChange = candidatesToPush.get("add");
@@ -4746,13 +4799,151 @@ function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mer
         addChange === void 0 || removeChange === void 0,
         "Fan-in:child expected either add or remove, not both"
       );
-      output.push(addEmptyRelationships(must(addChange ?? removeChange)));
+      output.push(
+        addEmptyRelationships(must(addChange ?? removeChange)),
+        pusher
+      );
       return;
     }
     default:
       fanOutChangeType;
   }
 }
+function mergeRelationships(left, right) {
+  if (left.type === right.type) {
+    switch (left.type) {
+      case "add": {
+        return {
+          type: "add",
+          node: {
+            row: left.node.row,
+            relationships: {
+              ...right.node.relationships,
+              ...left.node.relationships
+            }
+          }
+        };
+      }
+      case "remove": {
+        return {
+          type: "remove",
+          node: {
+            row: left.node.row,
+            relationships: {
+              ...right.node.relationships,
+              ...left.node.relationships
+            }
+          }
+        };
+      }
+      case "edit": {
+        assert(right.type === "edit");
+        return {
+          type: "edit",
+          node: {
+            row: left.node.row,
+            relationships: {
+              ...right.node.relationships,
+              ...left.node.relationships
+            }
+          },
+          oldNode: {
+            row: left.oldNode.row,
+            relationships: {
+              ...right.oldNode.relationships,
+              ...left.oldNode.relationships
+            }
+          }
+        };
+      }
+    }
+  }
+  assert(left.type === "edit");
+  switch (right.type) {
+    case "add": {
+      return {
+        type: "edit",
+        node: {
+          ...left.node,
+          relationships: {
+            ...right.node.relationships,
+            ...left.node.relationships
+          }
+        },
+        oldNode: left.oldNode
+      };
+    }
+    case "remove": {
+      return {
+        type: "edit",
+        node: left.node,
+        oldNode: {
+          ...left.oldNode,
+          relationships: {
+            ...right.node.relationships,
+            ...left.oldNode.relationships
+          }
+        }
+      };
+    }
+  }
+  unreachable();
+}
+function makeAddEmptyRelationships(schema) {
+  return (change) => {
+    if (Object.keys(schema.relationships).length === 0) {
+      return change;
+    }
+    switch (change.type) {
+      case "add":
+      case "remove": {
+        const ret = {
+          ...change,
+          node: {
+            ...change.node,
+            relationships: {
+              ...change.node.relationships
+            }
+          }
+        };
+        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));
+        return ret;
+      }
+      case "edit": {
+        const ret = {
+          ...change,
+          node: {
+            ...change.node,
+            relationships: {
+              ...change.node.relationships
+            }
+          },
+          oldNode: {
+            ...change.oldNode,
+            relationships: {
+              ...change.oldNode.relationships
+            }
+          }
+        };
+        mergeEmpty(ret.node.relationships, Object.keys(schema.relationships));
+        mergeEmpty(
+          ret.oldNode.relationships,
+          Object.keys(schema.relationships)
+        );
+        return ret;
+      }
+      case "child":
+        return change;
+    }
+  };
+}
+function mergeEmpty(relationships, relationshipNames) {
+  for (const relName of relationshipNames) {
+    if (relationships[relName] === void 0) {
+      relationships[relName] = () => emptyArray;
+    }
+  }
+}
 
 // ../zql/src/ivm/fan-in.ts
 var FanIn = class {
@@ -4796,6 +4987,7 @@ var FanIn = class {
     pushAccumulatedChanges(
       this.#accumulatedPushes,
       this.#output,
+      this,
       fanOutChangeType,
       identity,
       identity
@@ -4844,7 +5036,7 @@ var FanOut = class {
   }
   push(change) {
     for (const out of this.#outputs) {
-      out.push(change);
+      out.push(change, this);
     }
     must(
       this.#fanIn,
@@ -4854,44 +5046,50 @@ var FanOut = class {
 };
 
 // ../zql/src/ivm/maybe-split-and-push-edit-change.ts
-function maybeSplitAndPushEditChange(change, predicate, output) {
+function maybeSplitAndPushEditChange(change, predicate, output, pusher) {
   const oldWasPresent = predicate(change.oldNode.row);
   const newIsPresent = predicate(change.node.row);
   if (oldWasPresent && newIsPresent) {
-    output.push(change);
+    output.push(change, pusher);
   } else if (oldWasPresent && !newIsPresent) {
-    output.push({
-      type: "remove",
-      node: change.oldNode
-    });
+    output.push(
+      {
+        type: "remove",
+        node: change.oldNode
+      },
+      pusher
+    );
   } else if (!oldWasPresent && newIsPresent) {
-    output.push({
-      type: "add",
-      node: change.node
-    });
+    output.push(
+      {
+        type: "add",
+        node: change.node
+      },
+      pusher
+    );
   }
 }
 
 // ../zql/src/ivm/filter-push.ts
-function filterPush(change, output, predicate) {
+function filterPush(change, output, pusher, predicate) {
   if (!predicate) {
-    output.push(change);
+    output.push(change, pusher);
     return;
   }
   switch (change.type) {
     case "add":
     case "remove":
       if (predicate(change.node.row)) {
-        output.push(change);
+        output.push(change, pusher);
       }
       break;
     case "child":
       if (predicate(change.node.row)) {
-        output.push(change);
+        output.push(change, pusher);
       }
       break;
     case "edit":
-      maybeSplitAndPushEditChange(change, predicate, output);
+      maybeSplitAndPushEditChange(change, predicate, output, pusher);
       break;
     default:
       unreachable(change);
@@ -4921,10 +5119,85 @@ var Filter = class {
     return this.#input.getSchema();
   }
   push(change) {
-    filterPush(change, this.#output, this.#predicate);
+    filterPush(change, this.#output, this, this.#predicate);
   }
 };
 
+// ../zql/src/ivm/constraint.ts
+function constraintMatchesRow(constraint, row) {
+  for (const key in constraint) {
+    if (!valuesEqual(row[key], constraint[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function constraintsAreCompatible(left, right) {
+  for (const key in left) {
+    if (key in right && !valuesEqual(left[key], right[key])) {
+      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] !== primary[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function pullSimpleAndComponents(condition) {
+  if (condition.type === "and") {
+    return condition.conditions.flatMap(pullSimpleAndComponents);
+  }
+  if (condition.type === "simple") {
+    return [condition];
+  }
+  if (condition.type === "or" && condition.conditions.length === 1) {
+    return pullSimpleAndComponents(condition.conditions[0]);
+  }
+  return [];
+}
+function primaryKeyConstraintFromFilters(condition, primary) {
+  if (condition === void 0) {
+    return void 0;
+  }
+  const conditions = pullSimpleAndComponents(condition);
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  const ret = {};
+  for (const subCondition of conditions) {
+    if (subCondition.op === "=") {
+      const column = extractColumn(subCondition);
+      if (column !== void 0) {
+        if (!primary.includes(column.name)) {
+          continue;
+        }
+        ret[column.name] = column.value;
+      }
+    }
+  }
+  if (Object.keys(ret).length !== primary.length) {
+    return void 0;
+  }
+  return ret;
+}
+function extractColumn(condition) {
+  if (condition.left.type === "column") {
+    assert(condition.right.type === "literal");
+    return { name: condition.left.name, value: condition.right.value };
+  }
+  return void 0;
+}
+
 // ../zql/src/ivm/join-utils.ts
 function* generateWithOverlay(stream, overlay, schema) {
   let applied = false;
@@ -5089,7 +5362,7 @@ var FlippedJoin = class {
       const compare = this.#child.getSchema().compareRows;
       const insertPos = binarySearch(
         childNodes.length,
-        (i) => compare(childNodes[i].row, removedNode.row)
+        (i) => compare(removedNode.row, childNodes[i].row)
       );
       childNodes.splice(insertPos, 0, removedNode);
     }
@@ -5097,20 +5370,23 @@ var FlippedJoin = class {
     let threw = false;
     try {
       for (const childNode of childNodes) {
-        const stream = this.#parent.fetch({
-          ...req,
-          constraint: {
-            ...req.constraint,
-            ...Object.fromEntries(
-              this.#parentKey.map((key, i) => [
-                key,
-                childNode.row[this.#childKey[i]]
-              ])
-            )
-          }
-        });
-        const iterator = stream[Symbol.iterator]();
-        parentIterators.push(iterator);
+        const constraintFromChild = {};
+        for (let i = 0; i < this.#parentKey.length; i++) {
+          constraintFromChild[this.#parentKey[i]] = childNode.row[this.#childKey[i]];
+        }
+        if (req.constraint && !constraintsAreCompatible(constraintFromChild, req.constraint)) {
+          parentIterators.push(emptyArray[Symbol.iterator]());
+        } else {
+          const stream = this.#parent.fetch({
+            ...req,
+            constraint: {
+              ...req.constraint,
+              ...constraintFromChild
+            }
+          });
+          const iterator = stream[Symbol.iterator]();
+          parentIterators.push(iterator);
+        }
       }
       const nextParentNodes = [];
       for (let i = 0; i < parentIterators.length; i++) {
@@ -5156,19 +5432,17 @@ var FlippedJoin = class {
           minParentNode.row,
           this.#parentKey
         )) {
+          const hasInprogressChildChangeBeenPushedForMinParentNode = this.#parent.getSchema().compareRows(
+            minParentNode.row,
+            this.#inprogressChildChange.position
+          ) <= 0;
           if (this.#inprogressChildChange.change.type === "remove") {
-            if (this.#parent.getSchema().compareRows(
-              minParentNode.row,
-              this.#inprogressChildChange.position
-            ) <= 0) {
+            if (hasInprogressChildChangeBeenPushedForMinParentNode) {
               overlaidRelatedChildNodes = relatedChildNodes.filter(
                 (n) => n !== this.#inprogressChildChange?.change.node
               );
             }
-          } else if (this.#parent.getSchema().compareRows(
-            minParentNode.row,
-            this.#inprogressChildChange.position
-          ) > 0) {
+          } else if (!hasInprogressChildChangeBeenPushedForMinParentNode) {
             overlaidRelatedChildNodes = [
               ...generateWithOverlay(
                 relatedChildNodes,
@@ -5247,31 +5521,37 @@ var FlippedJoin = class {
             }
           }
           if (exists) {
-            this.#output.push({
-              type: "child",
-              node: {
-                ...parentNode,
-                relationships: {
-                  ...parentNode.relationships,
-                  [this.#relationshipName]: childNodeStream
+            this.#output.push(
+              {
+                type: "child",
+                node: {
+                  ...parentNode,
+                  relationships: {
+                    ...parentNode.relationships,
+                    [this.#relationshipName]: childNodeStream
+                  }
+                },
+                child: {
+                  relationshipName: this.#relationshipName,
+                  change
                 }
               },
-              child: {
-                relationshipName: this.#relationshipName,
-                change
-              }
-            });
+              this
+            );
           } else {
-            this.#output.push({
-              ...change,
-              node: {
-                ...parentNode,
-                relationships: {
-                  ...parentNode.relationships,
-                  [this.#relationshipName]: () => [change.node]
+            this.#output.push(
+              {
+                ...change,
+                node: {
+                  ...parentNode,
+                  relationships: {
+                    ...parentNode.relationships,
+                    [this.#relationshipName]: () => [change.node]
+                  }
                 }
-              }
-            });
+              },
+              this
+            );
           }
         }
       } finally {
@@ -5313,22 +5593,23 @@ var FlippedJoin = class {
         [this.#relationshipName]: childNodeStream(node)
       }
     });
+    if (first(childNodeStream(change.node)()) === void 0) {
+      return;
+    }
     switch (change.type) {
       case "add":
       case "remove":
       case "child": {
-        if (first(childNodeStream(change.node)()) === void 0) {
-          return;
-        }
-        this.#output.push({
-          ...change,
-          node: flip(change.node)
-        });
+        this.#output.push(
+          {
+            ...change,
+            node: flip(change.node)
+          },
+          this
+        );
         break;
       }
       case "edit": {
-        const oldHasChild = first(childNodeStream(change.oldNode)()) !== void 0;
-        const hasChild = first(childNodeStream(change.node)()) !== void 0;
         assert(
           rowEqualsForCompoundKey(
             change.oldNode.row,
@@ -5337,26 +5618,14 @@ var FlippedJoin = class {
           ),
           `Parent edit must not change relationship.`
         );
-        if (oldHasChild && hasChild) {
-          this.#output.push({
+        this.#output.push(
+          {
             type: "edit",
             oldNode: flip(change.oldNode),
             node: flip(change.node)
-          });
-          break;
-        }
-        if (oldHasChild) {
-          this.#output.push({
-            type: "remove",
-            node: flip(change.node)
-          });
-        }
-        if (hasChild) {
-          this.#output.push({
-            type: "add",
-            node: flip(change.node)
-          });
-        }
+          },
+          this
+        );
         break;
       }
       default:
@@ -5448,35 +5717,44 @@ var Join = class {
   #pushParent(change) {
     switch (change.type) {
       case "add":
-        this.#output.push({
-          type: "add",
-          node: this.#processParentNode(
-            change.node.row,
-            change.node.relationships,
-            "fetch"
-          )
-        });
+        this.#output.push(
+          {
+            type: "add",
+            node: this.#processParentNode(
+              change.node.row,
+              change.node.relationships,
+              "fetch"
+            )
+          },
+          this
+        );
         break;
       case "remove":
-        this.#output.push({
-          type: "remove",
-          node: this.#processParentNode(
-            change.node.row,
-            change.node.relationships,
-            "cleanup"
-          )
-        });
+        this.#output.push(
+          {
+            type: "remove",
+            node: this.#processParentNode(
+              change.node.row,
+              change.node.relationships,
+              "cleanup"
+            )
+          },
+          this
+        );
         break;
       case "child":
-        this.#output.push({
-          type: "child",
-          node: this.#processParentNode(
-            change.node.row,
-            change.node.relationships,
-            "fetch"
-          ),
-          child: change.child
-        });
+        this.#output.push(
+          {
+            type: "child",
+            node: this.#processParentNode(
+              change.node.row,
+              change.node.relationships,
+              "fetch"
+            ),
+            child: change.child
+          },
+          this
+        );
         break;
       case "edit": {
         assert(
@@ -5487,19 +5765,22 @@ var Join = class {
           ),
           `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"
-          )
-        });
+        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"
+            )
+          },
+          this
+        );
         break;
       }
       default:
@@ -5532,7 +5813,7 @@ var Join = class {
               change: change2
             }
           };
-          this.#output.push(childChange);
+          this.#output.push(childChange, this);
         }
       } finally {
         this.#inprogressChildChange = void 0;
@@ -5695,12 +5976,12 @@ var Skip = class {
   push(change) {
     const shouldBePresent = (row) => this.#shouldBePresent(row);
     if (change.type === "edit") {
-      maybeSplitAndPushEditChange(change, shouldBePresent, this.#output);
+      maybeSplitAndPushEditChange(change, shouldBePresent, this.#output, this);
       return;
     }
     change;
     if (shouldBePresent(change.node.row)) {
-      this.#output.push(change);
+      this.#output.push(change, this);
     }
   }
   #getStart(req) {
@@ -5900,7 +6181,7 @@ var Take = class {
           takeState.bound === void 0 || compareRows(takeState.bound, change.node.row) < 0 ? change.node.row : takeState.bound,
           maxBound
         );
-        this.#output.push(change);
+        this.#output.push(change, this);
         return;
       }
       if (takeState.bound === void 0 || compareRows(change.node.row, takeState.bound) >= 0) {
@@ -5944,9 +6225,9 @@ var Take = class {
         maxBound
       );
       this.#withRowHiddenFromFetch(change.node.row, () => {
-        this.#output.push(removeChange);
+        this.#output.push(removeChange, this);
       });
-      this.#output.push(change);
+      this.#output.push(change, this);
     } else if (change.type === "remove") {
       if (takeState.bound === void 0) {
         return;
@@ -5993,17 +6274,20 @@ var Take = class {
         }
       }
       if (newBound?.push) {
-        this.#output.push(change);
+        this.#output.push(change, this);
         this.#setTakeState(
           takeStateKey,
           takeState.size,
           newBound.node.row,
           maxBound
         );
-        this.#output.push({
-          type: "add",
-          node: newBound.node
-        });
+        this.#output.push(
+          {
+            type: "add",
+            node: newBound.node
+          },
+          this
+        );
         return;
       }
       this.#setTakeState(
@@ -6012,10 +6296,10 @@ var Take = class {
         newBound?.node.row,
         maxBound
       );
-      this.#output.push(change);
+      this.#output.push(change, this);
     } else if (change.type === "child") {
       if (takeState.bound && compareRows(change.node.row, takeState.bound) <= 0) {
-        this.#output.push(change);
+        this.#output.push(change, this);
       }
     }
   }
@@ -6039,11 +6323,11 @@ var Take = class {
         change.node.row,
         maxBound
       );
-      this.#output.push(change);
+      this.#output.push(change, this);
     };
     if (oldCmp === 0) {
       if (newCmp === 0) {
-        this.#output.push(change);
+        this.#output.push(change, this);
         return;
       }
       if (newCmp < 0) {
@@ -6069,7 +6353,7 @@ var Take = class {
           beforeBoundNode.row,
           maxBound
         );
-        this.#output.push(change);
+        this.#output.push(change, this);
         return;
       }
       assert(newCmp > 0);
@@ -6095,15 +6379,21 @@ var Take = class {
         maxBound
       );
       this.#withRowHiddenFromFetch(newBoundNode.row, () => {
-        this.#output.push({
-          type: "remove",
-          node: change.oldNode
-        });
-      });
-      this.#output.push({
-        type: "add",
-        node: newBoundNode
+        this.#output.push(
+          {
+            type: "remove",
+            node: change.oldNode
+          },
+          this
+        );
       });
+      this.#output.push(
+        {
+          type: "add",
+          node: newBoundNode
+        },
+        this
+      );
       return;
     }
     if (oldCmp > 0) {
@@ -6130,21 +6420,27 @@ var Take = class {
         maxBound
       );
       this.#withRowHiddenFromFetch(change.node.row, () => {
-        this.#output.push({
-          type: "remove",
-          node: oldBoundNode
-        });
-      });
-      this.#output.push({
-        type: "add",
-        node: change.node
+        this.#output.push(
+          {
+            type: "remove",
+            node: oldBoundNode
+          },
+          this
+        );
       });
+      this.#output.push(
+        {
+          type: "add",
+          node: change.node
+        },
+        this
+      );
       return;
     }
     if (oldCmp < 0) {
       assert(newCmp !== 0, "Invalid state. Row has duplicate primary key");
       if (newCmp < 0) {
-        this.#output.push(change);
+        this.#output.push(change, this);
         return;
       }
       assert(newCmp > 0);
@@ -6163,20 +6459,26 @@ var Take = class {
         replaceBoundAndForwardChange();
         return;
       }
-      this.#output.push({
-        type: "remove",
-        node: change.oldNode
-      });
+      this.#output.push(
+        {
+          type: "remove",
+          node: change.oldNode
+        },
+        this
+      );
       this.#setTakeState(
         takeStateKey,
         takeState.size,
         afterBoundNode.row,
         maxBound
       );
-      this.#output.push({
-        type: "add",
-        node: afterBoundNode
-      });
+      this.#output.push(
+        {
+          type: "add",
+          node: afterBoundNode
+        },
+        this
+      );
       return;
     }
     unreachable();
@@ -6237,6 +6539,212 @@ function makePartitionKeyComparator(partitionKey) {
   };
 }
 
+// ../zql/src/ivm/union-fan-in.ts
+var UnionFanIn = class {
+  #inputs;
+  #schema;
+  #fanOutPushStarted = false;
+  #output = throwOutput;
+  #accumulatedPushes = [];
+  constructor(fanOut, inputs) {
+    this.#inputs = inputs;
+    const fanOutSchema = fanOut.getSchema();
+    fanOut.setFanIn(this);
+    const schema = {
+      tableName: fanOutSchema.tableName,
+      columns: fanOutSchema.columns,
+      primaryKey: fanOutSchema.primaryKey,
+      relationships: {
+        ...fanOutSchema.relationships
+      },
+      isHidden: fanOutSchema.isHidden,
+      system: fanOutSchema.system,
+      compareRows: fanOutSchema.compareRows,
+      sort: fanOutSchema.sort
+    };
+    const relationshipsFromBranches = /* @__PURE__ */ new Set();
+    for (const input of inputs) {
+      const inputSchema = input.getSchema();
+      assert(
+        schema.tableName === inputSchema.tableName,
+        `Table name mismatch in union fan-in: ${schema.tableName} !== ${inputSchema.tableName}`
+      );
+      assert(
+        schema.primaryKey === inputSchema.primaryKey,
+        `Primary key mismatch in union fan-in`
+      );
+      assert(
+        schema.system === inputSchema.system,
+        `System mismatch in union fan-in: ${schema.system} !== ${inputSchema.system}`
+      );
+      assert(
+        schema.compareRows === inputSchema.compareRows,
+        `compareRows mismatch in union fan-in`
+      );
+      assert(schema.sort === inputSchema.sort, `Sort mismatch in union fan-in`);
+      for (const [relName, relSchema] of Object.entries(
+        inputSchema.relationships
+      )) {
+        if (relName in fanOutSchema.relationships) {
+          continue;
+        }
+        assert(
+          !relationshipsFromBranches.has(relName),
+          `Relationship ${relName} exists in multiple upstream inputs to union fan-in`
+        );
+        schema.relationships[relName] = relSchema;
+        relationshipsFromBranches.add(relName);
+      }
+      input.setOutput(this);
+    }
+    this.#schema = schema;
+    this.#inputs = inputs;
+  }
+  cleanup(_req) {
+    return [];
+  }
+  destroy() {
+    for (const input of this.#inputs) {
+      input.destroy();
+    }
+  }
+  fetch(req) {
+    const iterables = this.#inputs.map((input) => input.fetch(req));
+    return mergeIterables(
+      iterables,
+      (l, r) => this.#schema.compareRows(l.row, r.row),
+      true
+    );
+  }
+  getSchema() {
+    return this.#schema;
+  }
+  push(change, pusher) {
+    if (!this.#fanOutPushStarted) {
+      this.#pushInternalChange(change, pusher);
+    } else {
+      this.#accumulatedPushes.push(change);
+    }
+  }
+  /**
+   * An internal change means that a change was received inside the fan-out/fan-in sub-graph.
+   *
+   * These changes always come from children of a flip-join as no other push generating operators
+   * currently exist between union-fan-in and union-fan-out. All other pushes
+   * enter into union-fan-out before reaching union-fan-in.
+   *
+   * - normal joins for `exists` come before `union-fan-out`
+   * - joins for `related` come after `union-fan-out`
+   * - take comes after `union-fan-out`
+   *
+   * The algorithm for deciding whether or not to forward a push that came from inside the ufo/ufi sub-graph:
+   * 1. If the change is a `child` change we can forward it. This is because all child branches in the ufo/ufi sub-graph are unique.
+   * 2. If the change is `add` we can forward it iff no `fetches` for the row return any results.
+   *    If another branch has it, the add was already emitted in the past.
+   * 3. If the change is `remove` we can forward it iff no `fetches` for the row return any results.
+   *    If no other branches have the change, the remove can be sent as the value is no longer present.
+   *    If other branches have it, the last branch the processes the remove will send the remove.
+   * 4. Edits will always come through as child changes as flip join will flip them into children.
+   *    An edit that would result in a remove or add will have been split into an add/remove pair rather than being an edit.
+   */
+  #pushInternalChange(change, pusher) {
+    if (change.type === "child") {
+      this.#output.push(change, this);
+      return;
+    }
+    assert(change.type === "add" || change.type === "remove");
+    let hadMatch = false;
+    for (const input of this.#inputs) {
+      if (input === pusher) {
+        hadMatch = true;
+        continue;
+      }
+      const constraint = {};
+      for (const key of this.#schema.primaryKey) {
+        constraint[key] = change.node.row[key];
+      }
+      const fetchResult = input.fetch({
+        constraint
+      });
+      if (first(fetchResult) !== void 0) {
+        return;
+      }
+    }
+    assert(hadMatch, "Pusher was not one of the inputs to union-fan-in!");
+    this.#output.push(change, this);
+  }
+  fanOutStartedPushing() {
+    assert(this.#fanOutPushStarted === false);
+    this.#fanOutPushStarted = true;
+  }
+  fanOutDonePushing(fanOutChangeType) {
+    assert(this.#fanOutPushStarted);
+    this.#fanOutPushStarted = false;
+    if (this.#inputs.length === 0) {
+      return;
+    }
+    if (this.#accumulatedPushes.length === 0) {
+      return;
+    }
+    pushAccumulatedChanges(
+      this.#accumulatedPushes,
+      this.#output,
+      this,
+      fanOutChangeType,
+      mergeRelationships,
+      makeAddEmptyRelationships(this.#schema)
+    );
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+};
+
+// ../zql/src/ivm/union-fan-out.ts
+var UnionFanOut = class {
+  #destroyCount = 0;
+  #unionFanIn;
+  #input;
+  #outputs = [];
+  constructor(input) {
+    this.#input = input;
+    input.setOutput(this);
+  }
+  setFanIn(fanIn) {
+    assert(!this.#unionFanIn, "FanIn already set for this FanOut");
+    this.#unionFanIn = fanIn;
+  }
+  push(change) {
+    must(this.#unionFanIn).fanOutStartedPushing();
+    for (const output of this.#outputs) {
+      output.push(change, this);
+    }
+    must(this.#unionFanIn).fanOutDonePushing(change.type);
+  }
+  setOutput(output) {
+    this.#outputs.push(output);
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  fetch(req) {
+    return this.#input.fetch(req);
+  }
+  cleanup(_req) {
+    return [];
+  }
+  destroy() {
+    if (this.#destroyCount < this.#outputs.length) {
+      ++this.#destroyCount;
+      if (this.#destroyCount === this.#outputs.length) {
+        this.#input.destroy();
+      }
+    } else {
+      throw new Error("FanOut already destroyed once for each output");
+    }
+  }
+};
+
 // ../zql/src/query/expression.ts
 var ExpressionBuilder = class {
   #exists;
@@ -6602,27 +7110,23 @@ function transformFilters(filters) {
 
 // ../zql/src/builder/builder.ts
 function buildPipeline(ast, delegate, queryID) {
-  return buildPipelineInternal(
-    delegate.mapAst ? delegate.mapAst(ast) : ast,
-    delegate,
-    queryID,
-    ""
-  );
+  ast = delegate.mapAst ? delegate.mapAst(ast) : ast;
+  return buildPipelineInternal(ast, delegate, queryID, "");
 }
+var EXISTS_LIMIT = 3;
+var PERMISSIONS_EXISTS_LIMIT = 1;
 function buildPipelineInternal(ast, delegate, queryID, name, partitionKey) {
   const source = delegate.getSource(ast.table);
   if (!source) {
     throw new Error(`Source not found: ${ast.table}`);
   }
   ast = uniquifyCorrelatedSubqueryConditionAliases(ast);
-  const csqsFromCondition = gatherCorrelatedSubqueryQueriesFromCondition(
-    ast.where
-  );
+  const csqConditions = gatherCorrelatedSubqueryQueryConditions(ast.where);
   const splitEditKeys = partitionKey ? new Set(partitionKey) : /* @__PURE__ */ new Set();
   const aliases = /* @__PURE__ */ new Set();
-  for (const csq of csqsFromCondition) {
-    aliases.add(csq.subquery.alias || "");
-    for (const key of csq.correlation.parentField) {
+  for (const csq of csqConditions) {
+    aliases.add(csq.related.subquery.alias || "");
+    for (const key of csq.related.correlation.parentField) {
       splitEditKeys.add(key);
     }
   }
@@ -6647,8 +7151,23 @@ function buildPipelineInternal(ast, delegate, queryID, name, partitionKey) {
     delegate.addEdge(end, skip);
     end = delegate.decorateInput(skip, `${name}:skip)`);
   }
-  for (const csq of csqsFromCondition) {
-    end = applyCorrelatedSubQuery(csq, delegate, queryID, end, name, true);
+  for (const csqCondition of csqConditions) {
+    if (!csqCondition.flip) {
+      end = applyCorrelatedSubQuery(
+        {
+          ...csqCondition.related,
+          subquery: {
+            ...csqCondition.related.subquery,
+            limit: csqCondition.related.system === "permissions" ? PERMISSIONS_EXISTS_LIMIT : EXISTS_LIMIT
+          }
+        },
+        delegate,
+        queryID,
+        end,
+        name,
+        true
+      );
+    }
   }
   if (ast.where && (!fullyAppliedFilters || delegate.applyFiltersAnyway)) {
     end = applyWhere(end, ast.where, delegate, name);
@@ -6672,11 +7191,113 @@ function buildPipelineInternal(ast, delegate, queryID, name, partitionKey) {
   return end;
 }
 function applyWhere(input, condition, delegate, name) {
-  return buildFilterPipeline(
-    input,
-    delegate,
-    (filterInput) => applyFilter(filterInput, condition, delegate, name)
-  );
+  if (!conditionIncludesFlippedSubqueryAtAnyLevel(condition)) {
+    return buildFilterPipeline(
+      input,
+      delegate,
+      (filterInput) => applyFilter(filterInput, condition, delegate, name)
+    );
+  }
+  return applyFilterWithFlips(input, condition, delegate, name);
+}
+function applyFilterWithFlips(input, condition, delegate, name) {
+  let end = input;
+  assert(condition.type !== "simple", "Simple conditions cannot have flips");
+  switch (condition.type) {
+    case "and": {
+      const [withFlipped, withoutFlipped] = partitionBranches(
+        condition.conditions,
+        conditionIncludesFlippedSubqueryAtAnyLevel
+      );
+      if (withoutFlipped.length > 0) {
+        end = buildFilterPipeline(
+          input,
+          delegate,
+          (filterInput) => applyAnd(
+            filterInput,
+            {
+              type: "and",
+              conditions: withoutFlipped
+            },
+            delegate,
+            name
+          )
+        );
+      }
+      assert(withFlipped.length > 0, "Impossible to have no flips here");
+      for (const cond of withFlipped) {
+        end = applyFilterWithFlips(end, cond, delegate, name);
+      }
+      break;
+    }
+    case "or": {
+      const [withFlipped, withoutFlipped] = partitionBranches(
+        condition.conditions,
+        conditionIncludesFlippedSubqueryAtAnyLevel
+      );
+      assert(withFlipped.length > 0, "Impossible to have no flips here");
+      const ufo = new UnionFanOut(end);
+      delegate.addEdge(end, ufo);
+      end = delegate.decorateInput(ufo, `${name}:ufo`);
+      const branches = [];
+      if (withoutFlipped.length > 0) {
+        branches.push(
+          buildFilterPipeline(
+            end,
+            delegate,
+            (filterInput) => applyOr(
+              filterInput,
+              {
+                type: "or",
+                conditions: withoutFlipped
+              },
+              delegate,
+              name
+            )
+          )
+        );
+      }
+      for (const cond of withFlipped) {
+        branches.push(applyFilterWithFlips(end, cond, delegate, name));
+      }
+      const ufi = new UnionFanIn(ufo, branches);
+      for (const branch of branches) {
+        delegate.addEdge(branch, ufi);
+      }
+      end = delegate.decorateInput(ufi, `${name}:ufi`);
+      break;
+    }
+    case "correlatedSubquery": {
+      const sq = condition.related;
+      const child = buildPipelineInternal(
+        sq.subquery,
+        delegate,
+        "",
+        `${name}.${sq.subquery.alias}`,
+        sq.correlation.childField
+      );
+      const flippedJoin = new FlippedJoin({
+        parent: end,
+        child,
+        parentKey: sq.correlation.parentField,
+        childKey: sq.correlation.childField,
+        relationshipName: must(
+          sq.subquery.alias,
+          "Subquery must have an alias"
+        ),
+        hidden: sq.hidden ?? false,
+        system: sq.system ?? "client"
+      });
+      delegate.addEdge(end, flippedJoin);
+      delegate.addEdge(child, flippedJoin);
+      end = delegate.decorateInput(
+        flippedJoin,
+        `${name}:flipped-join(${sq.subquery.alias})`
+      );
+      break;
+    }
+  }
+  return end;
 }
 function applyFilter(input, condition, delegate, name) {
   switch (condition.type) {
@@ -6783,16 +7404,8 @@ function applyCorrelatedSubQuery(sq, delegate, queryID, end, name, fromCondition
     `${name}.${sq.subquery.alias}`,
     sq.correlation.childField
   );
-  const joinName = `${name}:${sq.flip ? "flipped-join" : "join"}(${sq.subquery.alias})`;
-  const join = sq.flip ? new FlippedJoin({
-    parent: end,
-    child,
-    parentKey: sq.correlation.parentField,
-    childKey: sq.correlation.childField,
-    relationshipName: sq.subquery.alias,
-    hidden: sq.hidden ?? false,
-    system: sq.system ?? "client"
-  }) : new Join({
+  const joinName = `${name}:join(${sq.subquery.alias})`;
+  const join = new Join({
     parent: end,
     child,
     storage: delegate.createStorage(joinName),
@@ -6829,18 +7442,11 @@ function applyCorrelatedSubqueryCondition(input, condition, delegate, name) {
   delegate.addEdge(input, exists);
   return delegate.decorateFilterInput(exists, existsName);
 }
-function gatherCorrelatedSubqueryQueriesFromCondition(condition) {
+function gatherCorrelatedSubqueryQueryConditions(condition) {
   const csqs = [];
   const gather = (condition2) => {
     if (condition2.type === "correlatedSubquery") {
-      assert(condition2.op === "EXISTS" || condition2.op === "NOT EXISTS");
-      csqs.push({
-        ...condition2.related,
-        subquery: {
-          ...condition2.related.subquery,
-          limit: condition2.related.system === "permissions" ? PERMISSIONS_EXISTS_LIMIT : EXISTS_LIMIT
-        }
-      });
+      csqs.push(condition2);
       return;
     }
     if (condition2.type === "and" || condition2.type === "or") {
@@ -6855,8 +7461,6 @@ function gatherCorrelatedSubqueryQueriesFromCondition(condition) {
   }
   return csqs;
 }
-var EXISTS_LIMIT = 3;
-var PERMISSIONS_EXISTS_LIMIT = 1;
 function assertOrderingIncludesPK(ordering, pk) {
   const orderingFields = ordering.map(([field]) => field);
   const missingFields = pk.filter((pkField) => !orderingFields.includes(pkField));
@@ -6912,6 +7516,29 @@ function uniquifyCorrelatedSubqueryConditionAliases(ast) {
   };
   return result;
 }
+function conditionIncludesFlippedSubqueryAtAnyLevel(cond) {
+  if (cond.type === "correlatedSubquery") {
+    return !!cond.flip;
+  }
+  if (cond.type === "and" || cond.type === "or") {
+    return cond.conditions.some(
+      (c) => conditionIncludesFlippedSubqueryAtAnyLevel(c)
+    );
+  }
+  return false;
+}
+function partitionBranches(conditions, predicate) {
+  const matched = [];
+  const notMatched = [];
+  for (const c of conditions) {
+    if (predicate(c)) {
+      matched.push(c);
+    } else {
+      notMatched.push(c);
+    }
+  }
+  return [matched, notMatched];
+}
 
 // ../zql/src/error.ts
 var NotImplementedError = class extends Error {
@@ -7415,10 +8042,10 @@ var AbstractQuery = class {
           subquery: addPrimaryKeysToAst(
             this.#schema.tables[destSchema],
             sq._ast
-          ),
-          flip
+          )
         },
-        op: "EXISTS"
+        op: "EXISTS",
+        flip
       };
     }
     if (isTwoHop(related)) {
@@ -7451,7 +8078,6 @@ var AbstractQuery = class {
             parentField: firstRelation.sourceField,
             childField: firstRelation.destField
           },
-          flip,
           subquery: {
             table: junctionSchema,
             alias: `${SUBQ_PREFIX}${relationship}`,
@@ -7470,14 +8096,15 @@ var AbstractQuery = class {
                 subquery: addPrimaryKeysToAst(
                   this.#schema.tables[destSchema],
                   queryToDest._ast
-                ),
-                flip
+                )
               },
-              op: "EXISTS"
+              op: "EXISTS",
+              flip
             }
           }
         },
-        op: "EXISTS"
+        op: "EXISTS",
+        flip
       };
     }
     throw new Error(`Invalid relationship ${relationship}`);
@@ -7817,6 +8444,9 @@ export {
   emptyFunction,
   emptyObject,
   filterPush,
+  constraintMatchesRow,
+  constraintMatchesPrimaryKey,
+  primaryKeyConstraintFromFilters,
   ExpressionBuilder,
   createPredicate,
   transformFilters,
@@ -7858,4 +8488,4 @@ export {
   TDigest,
   Inspector
 };
-//# sourceMappingURL=chunk-QZPMFA73.js.map
+//# sourceMappingURL=chunk-YXYKEMHQ.js.map