@rocicorp/zero 0.24.2025100900 → 0.24.2025101200

package/out/{chunk-2MVN6X6T.js → chunk-5J6ROZSO.js}

@@ -11,16 +11,20 @@ import {
   ClientStateNotFoundError,
   DD31,
   DEFAULT_HEAD_NAME,
+  DEFAULT_PRELOAD_TTL_MS,
+  DEFAULT_TTL_MS,
   DiffsMap,
   ENTITIES_KEY_PREFIX,
   GOT_QUERIES_KEY_PREFIX,
   Inspector,
   Latest,
   MUTATIONS_KEY_PREFIX,
+  SUBQ_PREFIX,
   TDigest,
   V6,
   V7,
   addDiffsForIndexes,
+  areEqual,
   assertClientV6,
   assertCookie,
   assertHasClientState,
@@ -28,7 +32,6 @@ import {
   assertJSONObject,
   assertJSONValue,
   assertLocalMetaDD31,
-  assertOrderingIncludesPK,
   assertRefs,
   assertSnapshotCommitDD31,
   assertSnapshotMetaDD31,
@@ -48,24 +51,16 @@ import {
   compareCookies,
   compareCookiesForSnapshots,
   compareTTL,
-  compareValues,
-  constraintMatchesPrimaryKey,
-  constraintMatchesRow,
   createChunk,
-  createPredicate,
   decodeIndexKey,
   deepEqual,
-  delegateSymbol,
   desiredQueriesPrefixForClient,
   diff,
   diff2,
   diffCommits,
   disableClientGroup,
-  emptyFunction,
   emptyHash,
-  emptyObject,
   encodeIndexScanKey,
-  filterPush,
   getClientGroup,
   getClientGroupForClient,
   getClientGroupIDForClient,
@@ -75,8 +70,6 @@ import {
   getSizeOfValue,
   h64,
   hasClientState,
-  hashOfAST,
-  hashOfNameAndArgs,
   initClientV6,
   inspectDownMessageSchema,
   isLocalMetaDD31,
@@ -88,24 +81,21 @@ import {
   localMutationsDD31,
   localMutationsGreaterThan,
   makeClientID,
-  makeComparator,
   mapAST,
   mapAllEntries,
   mapEntries,
-  materialize,
+  mergeIterables,
   must,
   mustGetChunk,
   mustGetClient,
   mustGetHeadHash,
   nanoid,
-  newQuery,
   newRandomHash,
   newWriteLocal,
   newWriteSnapshotDD31,
   normalizeAST,
   once,
   parse,
-  primaryKeyConstraintFromFilters,
   primaryKeySchema,
   primaryKeyValueRecordSchema,
   readFromDefaultHead,
@@ -122,23 +112,22 @@ import {
   sourceNameFromKey,
   stringCompare,
   test,
-  throwOutput,
   toDesiredQueriesKey,
   toGotQueriesKey,
   toMutationResponseKey,
   toPrimaryKeyString,
-  transformFilters,
+  toStaticParam,
   using,
   valita_exports,
-  valuesEqual,
   withRead,
   withWrite,
   withWriteNoImplicitCommit,
   wrapIterable
-} from "./chunk-YXYKEMHQ.js";
+} from "./chunk-HLJ3FQU5.js";
 import {
   assert,
   assertArray,
+  assertBoolean,
   assertNotNull,
   assertNumber,
   assertObject,
@@ -1859,6 +1848,334 @@ function clientSchemaFrom(schema) {
   return { clientSchema, hash };
 }
 
+// ../zql/src/ivm/data.ts
+import { compareUTF8 } from "compare-utf8";
+function compareValues(a, b) {
+  a = normalizeUndefined(a);
+  b = normalizeUndefined(b);
+  if (a === b) {
+    return 0;
+  }
+  if (a === null) {
+    return -1;
+  }
+  if (b === null) {
+    return 1;
+  }
+  if (typeof a === "boolean") {
+    assertBoolean(b);
+    return a ? 1 : -1;
+  }
+  if (typeof a === "number") {
+    assertNumber(b);
+    return a - b;
+  }
+  if (typeof a === "string") {
+    assertString(b);
+    return compareUTF8(a, b);
+  }
+  throw new Error(`Unsupported type: ${a}`);
+}
+function normalizeUndefined(v) {
+  return v ?? null;
+}
+function makeComparator(order, reverse) {
+  return (a, b) => {
+    for (const ord of order) {
+      const field = ord[0];
+      const comp = compareValues(a[field], b[field]);
+      if (comp !== 0) {
+        const result = ord[1] === "asc" ? comp : -comp;
+        return reverse ? -result : result;
+      }
+    }
+    return 0;
+  };
+}
+function valuesEqual(a, b) {
+  if (a == null || b == null) {
+    return false;
+  }
+  return a === b;
+}
+function drainStreams(node) {
+  for (const stream of Object.values(node.relationships)) {
+    for (const node2 of stream()) {
+      drainStreams(node2);
+    }
+  }
+}
+
+// ../zql/src/ivm/view-apply-change.ts
+var refCountSymbol = Symbol("rc");
+var idSymbol = Symbol("id");
+function applyChange(parentEntry, change, schema, relationship, format, withIDs = false) {
+  if (schema.isHidden) {
+    switch (change.type) {
+      case "add":
+      case "remove":
+        for (const [relationship2, children] of Object.entries(
+          change.node.relationships
+        )) {
+          const childSchema = must(schema.relationships[relationship2]);
+          for (const node of children()) {
+            applyChange(
+              parentEntry,
+              { type: change.type, node },
+              childSchema,
+              relationship2,
+              format,
+              withIDs
+            );
+          }
+        }
+        return;
+      case "edit":
+        return;
+      case "child": {
+        const childSchema = must(
+          schema.relationships[change.child.relationshipName]
+        );
+        applyChange(
+          parentEntry,
+          change.child.change,
+          childSchema,
+          relationship,
+          format,
+          withIDs
+        );
+        return;
+      }
+      default:
+        unreachable(change);
+    }
+  }
+  const { singular, relationships: childFormats } = format;
+  switch (change.type) {
+    case "add": {
+      let newEntry;
+      if (singular) {
+        const oldEntry = parentEntry[relationship];
+        if (oldEntry !== void 0) {
+          assert(
+            schema.compareRows(oldEntry, change.node.row) === 0,
+            `Singular relationship '${relationship}' should not have multiple rows. You may need to declare this relationship with the \`many\` helper instead of the \`one\` helper in your schema.`
+          );
+          oldEntry[refCountSymbol]++;
+        } else {
+          newEntry = makeNewMetaEntry(change.node.row, schema, withIDs, 1);
+          parentEntry[relationship] = newEntry;
+        }
+      } else {
+        newEntry = add(
+          change.node.row,
+          getChildEntryList(parentEntry, relationship),
+          schema,
+          withIDs
+        );
+      }
+      if (newEntry) {
+        for (const [relationship2, children] of Object.entries(
+          change.node.relationships
+        )) {
+          const childSchema = must(schema.relationships[relationship2]);
+          const childFormat = childFormats[relationship2];
+          if (childFormat === void 0) {
+            continue;
+          }
+          const newView = childFormat.singular ? void 0 : [];
+          newEntry[relationship2] = newView;
+          for (const node of children()) {
+            applyChange(
+              newEntry,
+              { type: "add", node },
+              childSchema,
+              relationship2,
+              childFormat,
+              withIDs
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "remove": {
+      if (singular) {
+        const oldEntry = parentEntry[relationship];
+        assert(oldEntry !== void 0, "node does not exist");
+        const rc = oldEntry[refCountSymbol];
+        if (rc === 1) {
+          parentEntry[relationship] = void 0;
+        }
+        oldEntry[refCountSymbol]--;
+      } else {
+        removeAndUpdateRefCount(
+          getChildEntryList(parentEntry, relationship),
+          change.node.row,
+          schema.compareRows
+        );
+      }
+      drainStreams(change.node);
+      break;
+    }
+    case "child": {
+      let existing;
+      if (singular) {
+        existing = getSingularEntry(parentEntry, relationship);
+      } else {
+        const view = getChildEntryList(parentEntry, relationship);
+        const { pos, found } = binarySearch2(
+          view,
+          change.node.row,
+          schema.compareRows
+        );
+        assert(found, "node does not exist");
+        existing = view[pos];
+      }
+      const childSchema = must(
+        schema.relationships[change.child.relationshipName]
+      );
+      const childFormat = format.relationships[change.child.relationshipName];
+      if (childFormat !== void 0) {
+        applyChange(
+          existing,
+          change.child.change,
+          childSchema,
+          change.child.relationshipName,
+          childFormat,
+          withIDs
+        );
+      }
+      break;
+    }
+    case "edit": {
+      if (singular) {
+        const existing = parentEntry[relationship];
+        assertMetaEntry(existing);
+        applyEdit(existing, change, schema, withIDs);
+      } else {
+        const view = getChildEntryList(parentEntry, relationship);
+        if (schema.compareRows(change.oldNode.row, change.node.row) !== 0) {
+          const { pos: oldPos, found: oldFound } = binarySearch2(
+            view,
+            change.oldNode.row,
+            schema.compareRows
+          );
+          assert(oldFound, "old node does not exist");
+          const oldEntry = view[oldPos];
+          const { pos, found } = binarySearch2(
+            view,
+            change.node.row,
+            schema.compareRows
+          );
+          if (oldEntry[refCountSymbol] === 1 && (pos === oldPos || pos - 1 === oldPos)) {
+            applyEdit(oldEntry, change, schema, withIDs);
+          } else {
+            oldEntry[refCountSymbol]--;
+            let adjustedPos = pos;
+            if (oldEntry[refCountSymbol] === 0) {
+              view.splice(oldPos, 1);
+              adjustedPos = oldPos < pos ? pos - 1 : pos;
+            }
+            let entryToEdit;
+            if (found) {
+              entryToEdit = view[adjustedPos];
+            } else {
+              view.splice(adjustedPos, 0, oldEntry);
+              entryToEdit = oldEntry;
+              if (oldEntry[refCountSymbol] > 0) {
+                const oldEntryCopy = { ...oldEntry };
+                view[oldPos] = oldEntryCopy;
+              }
+            }
+            entryToEdit[refCountSymbol]++;
+            applyEdit(entryToEdit, change, schema, withIDs);
+          }
+        } else {
+          const { pos, found } = binarySearch2(
+            view,
+            change.oldNode.row,
+            schema.compareRows
+          );
+          assert(found, "node does not exist");
+          applyEdit(view[pos], change, schema, withIDs);
+        }
+      }
+      break;
+    }
+    default:
+      unreachable(change);
+  }
+}
+function applyEdit(existing, change, schema, withIDs) {
+  Object.assign(existing, change.node.row);
+  if (withIDs) {
+    existing[idSymbol] = makeID(change.node.row, schema);
+  }
+}
+function add(row, view, schema, withIDs) {
+  const { pos, found } = binarySearch2(view, row, schema.compareRows);
+  if (found) {
+    view[pos][refCountSymbol]++;
+    return void 0;
+  }
+  const newEntry = makeNewMetaEntry(row, schema, withIDs, 1);
+  view.splice(pos, 0, newEntry);
+  return newEntry;
+}
+function removeAndUpdateRefCount(view, row, compareRows) {
+  const { pos, found } = binarySearch2(view, row, compareRows);
+  assert(found, "node does not exist");
+  const oldEntry = view[pos];
+  const rc = oldEntry[refCountSymbol];
+  if (rc === 1) {
+    view.splice(pos, 1);
+  }
+  oldEntry[refCountSymbol]--;
+  return oldEntry;
+}
+function binarySearch2(view, target, comparator2) {
+  let low = 0;
+  let high = view.length - 1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const comparison = comparator2(view[mid], target);
+    if (comparison < 0) {
+      low = mid + 1;
+    } else if (comparison > 0) {
+      high = mid - 1;
+    } else {
+      return { pos: mid, found: true };
+    }
+  }
+  return { pos: low, found: false };
+}
+function getChildEntryList(parentEntry, relationship) {
+  const view = parentEntry[relationship];
+  assertArray(view);
+  return view;
+}
+function assertMetaEntry(v) {
+  assertNumber(v[refCountSymbol]);
+}
+function getSingularEntry(parentEntry, relationship) {
+  const e = parentEntry[relationship];
+  assertNumber(e[refCountSymbol]);
+  return e;
+}
+function makeNewMetaEntry(row, schema, withIDs, rc) {
+  if (withIDs) {
+    return { ...row, [refCountSymbol]: rc, [idSymbol]: makeID(row, schema) };
+  }
+  return { ...row, [refCountSymbol]: rc };
+}
+function makeID(row, schema) {
+  if (schema.primaryKey.length === 1) {
+    return JSON.stringify(row[schema.primaryKey[0]]);
+  }
+  return JSON.stringify(schema.primaryKey.map((k) => row[k]));
+}
+
 // ../zero-client/src/client/update-needed-reason-type-enum.ts
 var update_needed_reason_type_enum_exports = {};
 __export(update_needed_reason_type_enum_exports, {
@@ -1872,7 +2189,7 @@ var SchemaVersionNotSupported2 = "SchemaVersionNotSupported";
 
 // ../zero-client/src/client/zero.ts
 import "@rocicorp/logger";
-import { resolver as resolver9 } from "@rocicorp/resolver";
+import { resolver as resolver10 } from "@rocicorp/resolver";
 
 // ../replicache/src/replicache-impl.ts
 import { Lock } from "@rocicorp/lock";
@@ -4421,7 +4738,7 @@ function setIntervalWithSignal(fn, ms, signal) {
 }
 
 // ../replicache/src/subscriptions.ts
-import { compareUTF8, greaterThan as greaterThan3, lessThan, lessThanEq } from "compare-utf8";
+import { compareUTF8 as compareUTF82, greaterThan as greaterThan3, lessThan, lessThanEq } from "compare-utf8";
 
 // ../replicache/src/invoke-kind-enum.ts
 var InitialRun = 0;
@@ -4764,7 +5081,7 @@ function watcherMatchesDiff(diff3, prefix, indexName) {
 function diffBinarySearch(diff3, prefix, compareKey) {
   return binarySearch(
     diff3.length,
-    (i) => compareUTF8(prefix, compareKey(diff3[i]))
+    (i) => compareUTF82(prefix, compareKey(diff3[i]))
   );
 }
 
@@ -5970,6 +6287,15 @@ function validateOptions(options) {
   }
 }
 
+// ../shared/src/sentinels.ts
+function emptyFunction() {
+}
+var emptyObject = Object.freeze({});
+var emptyArray = Object.freeze([]);
+function identity(x) {
+  return x;
+}
+
 // ../shared/src/subscribable.ts
 var Subscribable = class {
   _listeners = /* @__PURE__ */ new Set();
@@ -6428,46 +6754,11 @@ var downstreamSchema = valita_exports.union(
 );
 
 // ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 34;
+var PROTOCOL_VERSION = 36;
 var MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 18;
 assert(MIN_SERVER_SUPPORTED_SYNC_PROTOCOL < PROTOCOL_VERSION);
 
-// ../zero-schema/src/name-mapper.ts
-function clientToServer(tables) {
-  return createMapperFrom("client", tables);
-}
-function serverToClient(tables) {
-  return createMapperFrom("server", tables);
-}
-function createMapperFrom(src, tables) {
-  const mapping = new Map(
-    Object.entries(tables).map(
-      ([tableName, { serverName: serverTableName, columns }]) => {
-        let allColumnsSame = true;
-        const names = {};
-        for (const [name, { serverName }] of Object.entries(columns)) {
-          if (serverName && serverName !== name) {
-            allColumnsSame = false;
-          }
-          if (src === "client") {
-            names[name] = serverName ?? name;
-          } else {
-            names[serverName ?? name] = name;
-          }
-        }
-        return [
-          src === "client" ? tableName : serverTableName ?? tableName,
-          {
-            tableName: src === "client" ? serverTableName ?? tableName : tableName,
-            columns: names,
-            allColumnsSame
-          }
-        ];
-      }
-    )
-  );
-  return new NameMapper(mapping);
-}
+// ../zero-types/src/name-mapper.ts
 var NameMapper = class {
   #tables = /* @__PURE__ */ new Map();
   constructor(tables) {
@@ -6513,6 +6804,43 @@ var NameMapper = class {
   }
 };
 
+// ../zero-schema/src/name-mapper.ts
+function clientToServer(tables) {
+  return createMapperFrom("client", tables);
+}
+function serverToClient(tables) {
+  return createMapperFrom("server", tables);
+}
+function createMapperFrom(src, tables) {
+  const mapping = new Map(
+    Object.entries(tables).map(
+      ([tableName, { serverName: serverTableName, columns }]) => {
+        let allColumnsSame = true;
+        const names = {};
+        for (const [name, { serverName }] of Object.entries(columns)) {
+          if (serverName && serverName !== name) {
+            allColumnsSame = false;
+          }
+          if (src === "client") {
+            names[name] = serverName ?? name;
+          } else {
+            names[serverName ?? name] = name;
+          }
+        }
+        return [
+          src === "client" ? tableName : serverTableName ?? tableName,
+          {
+            tableName: src === "client" ? serverTableName ?? tableName : tableName,
+            columns: names,
+            allColumnsSame
+          }
+        ];
+      }
+    )
+  );
+  return new NameMapper(mapping);
+}
+
 // ../zql/src/mutate/custom.ts
 function customMutatorKey(namespace, name) {
   assert(!namespace.includes("|"), "mutator namespaces must not include a |");
@@ -6525,77 +6853,4099 @@ function isClientMetric(metric) {
   return metric.endsWith("-client") || metric.endsWith("-end-to-end");
 }
 
-// ../zero-client/src/util/socket.ts
-function send(ws, data) {
-  ws.send(JSON.stringify(data));
-}
-
-// ../zero-client/src/client/active-clients-manager.ts
+// ../zql/src/query/query-impl.ts
 import { resolver as resolver7 } from "@rocicorp/resolver";
-var keyPrefix = "zero-active";
-function toLockName(clientGroupID, clientID) {
-  return `${keyPrefix}/${clientGroupID}/${clientID}`;
+
+// ../zero-protocol/src/query-hash.ts
+var hashCache = /* @__PURE__ */ new WeakMap();
+function hashOfAST(ast) {
+  const normalized = normalizeAST(ast);
+  const cached = hashCache.get(normalized);
+  if (cached) {
+    return cached;
+  }
+  const hash = h64(JSON.stringify(normalized)).toString(36);
+  hashCache.set(normalized, hash);
+  return hash;
 }
-function toBroadcastChannelName(clientGroupID) {
-  return `${keyPrefix}/${clientGroupID}`;
+function hashOfNameAndArgs(name, args) {
+  const argsString = JSON.stringify(args);
+  return h64(`${name}:${argsString}`).toString(36);
 }
-function fromLockName(lockKey) {
-  if (!lockKey || !lockKey.startsWith(keyPrefix)) {
-    return void 0;
+
+// ../zql/src/ivm/filter-operators.ts
+var throwFilterOutput = {
+  push(_change) {
+    throw new Error("Output not set");
+  },
+  filter(_node, _cleanup) {
+    throw new Error("Output not set");
   }
-  const parts = lockKey.slice(keyPrefix.length).split("/");
-  if (parts.length !== 3) {
-    return void 0;
+};
+var FilterStart = class {
+  #input;
+  #output = throwFilterOutput;
+  constructor(input) {
+    this.#input = input;
+    input.setOutput(this);
   }
-  return {
-    clientGroupID: parts[1],
-    clientID: parts[2]
-  };
-}
-function ignoreAbortError(e) {
-  if (e instanceof Error && e.name === "AbortError") {
-    return;
+  setFilterOutput(output) {
+    this.#output = output;
   }
-  throw e;
-}
-var ActiveClientsManager = class _ActiveClientsManager {
-  clientGroupID;
-  clientID;
-  #resolver = resolver7();
-  #lockManager;
-  #activeClients = /* @__PURE__ */ new Set();
-  /**
-   * A callback that is called when a client is added to the client group.
-   * It receives the client ID of the added client.
-   */
-  onAdd;
-  /**
-   * A callback that is called when a client is deleted from the client group.
-   * It receives the client ID of the deleted client.
-   */
-  onDelete;
-  /**
-   * Creates an instance of `ActiveClientsManager` for the specified client
-   * group and client ID. It will return a promise that resolves when the
-   * instance is ready to use, which means that it has successfully acquired the
-   * exclusive lock for the client and has retrieved the list of active clients.
-   */
-  static async create(clientGroupID, clientID, signal) {
-    const instance = new _ActiveClientsManager(clientGroupID, clientID, signal);
-    await instance.#init(signal);
-    return instance;
+  destroy() {
+    this.#input.destroy();
   }
-  constructor(clientGroupID, clientID, signal) {
-    this.clientGroupID = clientGroupID;
-    this.clientID = clientID;
-    this.#lockManager = getClientLockManager(signal);
-    this.#activeClients.add(clientID);
+  getSchema() {
+    return this.#input.getSchema();
   }
-  async #init(signal) {
-    const { clientGroupID, clientID } = this;
-    const name = toLockName(clientGroupID, clientID);
-    const channel = new bc(toBroadcastChannelName(clientGroupID));
-    channel.addEventListener(
+  push(change) {
+    this.#output.push(change, this);
+  }
+  *fetch(req) {
+    for (const node of this.#input.fetch(req)) {
+      if (this.#output.filter(node, false)) {
+        yield node;
+      }
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#input.cleanup(req)) {
+      if (this.#output.filter(node, true)) {
+        yield node;
+      } else {
+        drainStreams(node);
+      }
+    }
+  }
+};
+var FilterEnd = class {
+  #start;
+  #input;
+  #output = throwFilterOutput;
+  constructor(start, input) {
+    this.#start = start;
+    this.#input = input;
+    input.setFilterOutput(this);
+  }
+  *fetch(req) {
+    for (const node of this.#start.fetch(req)) {
+      yield node;
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#start.cleanup(req)) {
+      yield node;
+    }
+  }
+  filter(_node, _cleanup) {
+    return true;
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  push(change) {
+    this.#output.push(change, this);
+  }
+};
+function buildFilterPipeline(input, delegate, pipeline) {
+  const filterStart = new FilterStart(input);
+  delegate.addEdge(input, filterStart);
+  const middle = pipeline(filterStart);
+  delegate.addEdge(filterStart, middle);
+  const filterEnd = new FilterEnd(filterStart, middle);
+  delegate.addEdge(middle, filterEnd);
+  return filterEnd;
+}
+
+// ../zql/src/ivm/operator.ts
+var throwOutput = {
+  push(_change) {
+    throw new Error("Output not set");
+  }
+};
+
+// ../zql/src/ivm/stream.ts
+function* take(stream, limit) {
+  if (limit < 1) {
+    return;
+  }
+  let count = 0;
+  for (const v of stream) {
+    yield v;
+    if (++count === limit) {
+      break;
+    }
+  }
+}
+function first(stream) {
+  const it = stream[Symbol.iterator]();
+  const { value } = it.next();
+  it.return?.();
+  return value;
+}
+
+// ../zql/src/ivm/exists.ts
+var Exists = class {
+  #input;
+  #relationshipName;
+  #storage;
+  #not;
+  #parentJoinKey;
+  #noSizeReuse;
+  #output = throwFilterOutput;
+  /**
+   * This instance variable is `true` when this operator is processing a `push`,
+   * and is used to disable reuse of cached sizes across rows with the
+   * same parent join key value.
+   * This is necessary because during a push relationships can be inconsistent
+   * due to push communicating changes (which may change multiple Nodes) one
+   * Node at a time.
+   */
+  #inPush = false;
+  constructor(input, storage, relationshipName, parentJoinKey, type) {
+    this.#input = input;
+    this.#relationshipName = relationshipName;
+    this.#input.setFilterOutput(this);
+    this.#storage = storage;
+    assert(
+      this.#input.getSchema().relationships[relationshipName],
+      `Input schema missing ${relationshipName}`
+    );
+    this.#not = type === "NOT EXISTS";
+    this.#parentJoinKey = parentJoinKey;
+    this.#noSizeReuse = areEqual(
+      parentJoinKey,
+      this.#input.getSchema().primaryKey
+    );
+  }
+  setFilterOutput(output) {
+    this.#output = output;
+  }
+  filter(node, cleanup) {
+    const result = this.#filter(node) && this.#output.filter(node, cleanup);
+    if (cleanup) {
+      this.#delSize(node);
+    }
+    return result;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  push(change) {
+    assert(!this.#inPush, "Unexpected re-entrancy");
+    this.#inPush = true;
+    try {
+      switch (change.type) {
+        // add, remove and edit cannot change the size of the
+        // this.#relationshipName relationship, so simply #pushWithFilter
+        case "add":
+        case "edit": {
+          this.#pushWithFilter(change);
+          return;
+        }
+        case "remove": {
+          const size = this.#getSize(change.node);
+          if (size === void 0) {
+            return;
+          }
+          this.#pushWithFilter(change, size);
+          this.#delSize(change.node);
+          return;
+        }
+        case "child":
+          if (change.child.relationshipName !== this.#relationshipName || change.child.change.type === "edit" || change.child.change.type === "child") {
+            this.#pushWithFilter(change);
+            return;
+          }
+          switch (change.child.change.type) {
+            case "add": {
+              let size = this.#getSize(change.node);
+              if (size !== void 0) {
+                size++;
+                this.#setSize(change.node, size);
+              } else {
+                size = this.#fetchSize(change.node);
+              }
+              if (size === 1) {
+                if (this.#not) {
+                  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
+                  );
+                }
+              } else {
+                this.#pushWithFilter(change, size);
+              }
+              return;
+            }
+            case "remove": {
+              let size = this.#getSize(change.node);
+              if (size !== void 0) {
+                assert(size > 0);
+                size--;
+                this.#setSize(change.node, size);
+              } else {
+                size = this.#fetchSize(change.node);
+              }
+              if (size === 0) {
+                if (this.#not) {
+                  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
+                  );
+                }
+              } else {
+                this.#pushWithFilter(change, size);
+              }
+              return;
+            }
+          }
+          return;
+        default:
+          unreachable(change);
+      }
+    } finally {
+      this.#inPush = false;
+    }
+  }
+  /**
+   * Returns whether or not the node's this.#relationshipName
+   * relationship passes the exist/not exists filter condition.
+   * If the optional `size` is passed it is used.
+   * Otherwise, if there is a stored size for the row it is used.
+   * Otherwise the size is computed by streaming the node's
+   * relationship with this.#relationshipName (this computed size is also
+   * stored).
+   */
+  #filter(node, size) {
+    const exists = (size ?? this.#getOrFetchSize(node)) > 0;
+    return this.#not ? !exists : exists;
+  }
+  /**
+   * Pushes a change if this.#filter is true for its row.
+   */
+  #pushWithFilter(change, size) {
+    if (this.#filter(change.node, size)) {
+      this.#output.push(change, this);
+    }
+  }
+  #getSize(node) {
+    return this.#storage.get(this.#makeSizeStorageKey(node));
+  }
+  #setSize(node, size) {
+    this.#storage.set(this.#makeSizeStorageKey(node), size);
+  }
+  #delSize(node) {
+    this.#storage.del(this.#makeSizeStorageKey(node));
+  }
+  #getOrFetchSize(node) {
+    const size = this.#getSize(node);
+    if (size !== void 0) {
+      return size;
+    }
+    return this.#fetchSize(node);
+  }
+  #fetchSize(node) {
+    if (!this.#noSizeReuse && !this.#inPush) {
+      const cachedSizeEntry = first(
+        this.#storage.scan({
+          prefix: this.#makeSizeStorageKeyPrefix(node)
+        })
+      );
+      if (cachedSizeEntry !== void 0) {
+        this.#setSize(node, cachedSizeEntry[1]);
+        return cachedSizeEntry[1];
+      }
+    }
+    const relationship = node.relationships[this.#relationshipName];
+    assert(relationship);
+    let size = 0;
+    for (const _relatedNode of relationship()) {
+      size++;
+    }
+    this.#setSize(node, size);
+    return size;
+  }
+  #makeSizeStorageKeyPrefix(node) {
+    return `row/${this.#noSizeReuse ? "" : JSON.stringify(this.#getKeyValues(node, this.#parentJoinKey))}/`;
+  }
+  #makeSizeStorageKey(node) {
+    return `${this.#makeSizeStorageKeyPrefix(node)}${JSON.stringify(
+      this.#getKeyValues(node, this.#input.getSchema().primaryKey)
+    )}`;
+  }
+  #getKeyValues(node, def) {
+    const values = [];
+    for (const key of def) {
+      values.push(normalizeUndefined(node.row[key]));
+    }
+    return values;
+  }
+};
+
+// ../zql/src/ivm/push-accumulated.ts
+function pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChangeType, mergeRelationships2, addEmptyRelationships) {
+  if (accumulatedPushes.length === 0) {
+    return;
+  }
+  const candidatesToPush = /* @__PURE__ */ new Map();
+  for (const change of accumulatedPushes) {
+    if (fanOutChangeType === "child" && change.type !== "child") {
+      assert(
+        candidatesToPush.has(change.type) === false,
+        () => `Fan-in:child expected at most one ${change.type} when fan-out is of type child`
+      );
+    }
+    const existing = candidatesToPush.get(change.type);
+    let mergedChange = change;
+    if (existing) {
+      mergedChange = mergeRelationships2(existing, change);
+    }
+    candidatesToPush.set(change.type, mergedChange);
+  }
+  accumulatedPushes.length = 0;
+  const types = [...candidatesToPush.keys()];
+  switch (fanOutChangeType) {
+    case "remove":
+      assert(
+        types.length === 1 && types[0] === "remove",
+        "Fan-in:remove expected all removes"
+      );
+      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"))),
+        pusher
+      );
+      return;
+    case "edit": {
+      assert(
+        types.every(
+          (type) => type === "add" || type === "remove" || type === "edit"
+        ),
+        "Fan-in:edit expected all adds, removes, or edits"
+      );
+      const addChange = candidatesToPush.get("add");
+      const removeChange = candidatesToPush.get("remove");
+      let editChange = candidatesToPush.get("edit");
+      if (editChange) {
+        if (addChange) {
+          editChange = mergeRelationships2(editChange, addChange);
+        }
+        if (removeChange) {
+          editChange = mergeRelationships2(editChange, removeChange);
+        }
+        output.push(addEmptyRelationships(editChange), pusher);
+        return;
+      }
+      if (addChange && removeChange) {
+        output.push(
+          addEmptyRelationships({
+            type: "edit",
+            node: addChange.node,
+            oldNode: removeChange.node
+          }),
+          pusher
+        );
+        return;
+      }
+      output.push(
+        addEmptyRelationships(must(addChange ?? removeChange)),
+        pusher
+      );
+      return;
+    }
+    case "child": {
+      assert(
+        types.every(
+          (type) => type === "add" || // exists can change child to add or remove
+          type === "remove" || // exists can change child to add or remove
+          type === "child"
+          // other operators may preserve the child change
+        ),
+        "Fan-in:child expected all adds, removes, or children"
+      );
+      assert(
+        types.length <= 2,
+        "Fan-in:child expected at most 2 types on a child change from fan-out"
+      );
+      const childChange = candidatesToPush.get("child");
+      if (childChange) {
+        output.push(childChange, pusher);
+        return;
+      }
+      const addChange = candidatesToPush.get("add");
+      const removeChange = candidatesToPush.get("remove");
+      assert(
+        addChange === void 0 || removeChange === void 0,
+        "Fan-in:child expected either add or remove, not both"
+      );
+      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 {
+  #inputs;
+  #schema;
+  #output = throwFilterOutput;
+  #accumulatedPushes = [];
+  constructor(fanOut, inputs) {
+    this.#inputs = inputs;
+    this.#schema = fanOut.getSchema();
+    for (const input of inputs) {
+      input.setFilterOutput(this);
+      assert(this.#schema === input.getSchema(), `Schema mismatch in fan-in`);
+    }
+  }
+  setFilterOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    for (const input of this.#inputs) {
+      input.destroy();
+    }
+  }
+  getSchema() {
+    return this.#schema;
+  }
+  filter(node, cleanup) {
+    return this.#output.filter(node, cleanup);
+  }
+  push(change) {
+    this.#accumulatedPushes.push(change);
+  }
+  fanOutDonePushingToAllBranches(fanOutChangeType) {
+    if (this.#inputs.length === 0) {
+      assert(
+        this.#accumulatedPushes.length === 0,
+        "If there are no inputs then fan-in should not receive any pushes."
+      );
+      return;
+    }
+    pushAccumulatedChanges(
+      this.#accumulatedPushes,
+      this.#output,
+      this,
+      fanOutChangeType,
+      identity,
+      identity
+    );
+  }
+};
+
+// ../zql/src/ivm/fan-out.ts
+var FanOut = class {
+  #input;
+  #outputs = [];
+  #fanIn;
+  #destroyCount = 0;
+  constructor(input) {
+    this.#input = input;
+    input.setFilterOutput(this);
+  }
+  setFanIn(fanIn) {
+    this.#fanIn = fanIn;
+  }
+  setFilterOutput(output) {
+    this.#outputs.push(output);
+  }
+  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");
+    }
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  filter(node, cleanup) {
+    let result = false;
+    for (const output of this.#outputs) {
+      result = output.filter(node, cleanup) || result;
+      if (!cleanup && result) {
+        return true;
+      }
+    }
+    return result;
+  }
+  push(change) {
+    for (const out of this.#outputs) {
+      out.push(change, this);
+    }
+    must(
+      this.#fanIn,
+      "fan-out must have a corresponding fan-in set!"
+    ).fanOutDonePushingToAllBranches(change.type);
+  }
+};
+
+// ../zql/src/ivm/maybe-split-and-push-edit-change.ts
+function maybeSplitAndPushEditChange(change, predicate, output, pusher) {
+  const oldWasPresent = predicate(change.oldNode.row);
+  const newIsPresent = predicate(change.node.row);
+  if (oldWasPresent && newIsPresent) {
+    output.push(change, pusher);
+  } else if (oldWasPresent && !newIsPresent) {
+    output.push(
+      {
+        type: "remove",
+        node: change.oldNode
+      },
+      pusher
+    );
+  } else if (!oldWasPresent && newIsPresent) {
+    output.push(
+      {
+        type: "add",
+        node: change.node
+      },
+      pusher
+    );
+  }
+}
+
+// ../zql/src/ivm/filter-push.ts
+function filterPush(change, output, pusher, predicate) {
+  if (!predicate) {
+    output.push(change, pusher);
+    return;
+  }
+  switch (change.type) {
+    case "add":
+    case "remove":
+      if (predicate(change.node.row)) {
+        output.push(change, pusher);
+      }
+      break;
+    case "child":
+      if (predicate(change.node.row)) {
+        output.push(change, pusher);
+      }
+      break;
+    case "edit":
+      maybeSplitAndPushEditChange(change, predicate, output, pusher);
+      break;
+    default:
+      unreachable(change);
+  }
+}
+
+// ../zql/src/ivm/filter.ts
+var Filter = class {
+  #input;
+  #predicate;
+  #output = throwFilterOutput;
+  constructor(input, predicate) {
+    this.#input = input;
+    this.#predicate = predicate;
+    input.setFilterOutput(this);
+  }
+  filter(node, cleanup) {
+    return this.#predicate(node.row) && this.#output.filter(node, cleanup);
+  }
+  setFilterOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  push(change) {
+    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;
+  let editOldApplied = false;
+  let editNewApplied = false;
+  for (const node of stream) {
+    let yieldNode = true;
+    if (!applied) {
+      switch (overlay.type) {
+        case "add": {
+          if (schema.compareRows(overlay.node.row, node.row) === 0) {
+            applied = true;
+            yieldNode = false;
+          }
+          break;
+        }
+        case "remove": {
+          if (schema.compareRows(overlay.node.row, node.row) < 0) {
+            applied = true;
+            yield overlay.node;
+          }
+          break;
+        }
+        case "edit": {
+          if (!editOldApplied && schema.compareRows(overlay.oldNode.row, node.row) < 0) {
+            editOldApplied = true;
+            if (editNewApplied) {
+              applied = true;
+            }
+            yield overlay.oldNode;
+          }
+          if (!editNewApplied && schema.compareRows(overlay.node.row, node.row) === 0) {
+            editNewApplied = true;
+            if (editOldApplied) {
+              applied = true;
+            }
+            yieldNode = false;
+          }
+          break;
+        }
+        case "child": {
+          if (schema.compareRows(overlay.node.row, node.row) === 0) {
+            applied = true;
+            yield {
+              row: node.row,
+              relationships: {
+                ...node.relationships,
+                [overlay.child.relationshipName]: () => generateWithOverlay(
+                  node.relationships[overlay.child.relationshipName](),
+                  overlay.child.change,
+                  schema.relationships[overlay.child.relationshipName]
+                )
+              }
+            };
+            yieldNode = false;
+          }
+          break;
+        }
+      }
+    }
+    if (yieldNode) {
+      yield node;
+    }
+  }
+  if (!applied) {
+    if (overlay.type === "remove") {
+      applied = true;
+      yield overlay.node;
+    } else if (overlay.type === "edit") {
+      assert(editNewApplied);
+      editOldApplied = true;
+      applied = true;
+      yield overlay.oldNode;
+    }
+  }
+  assert(applied);
+}
+function rowEqualsForCompoundKey(a, b, key) {
+  for (let i = 0; i < key.length; i++) {
+    if (compareValues(a[key[i]], b[key[i]]) !== 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function isJoinMatch(parent, parentKey, child, childKey) {
+  for (let i = 0; i < parentKey.length; i++) {
+    if (!valuesEqual(parent[parentKey[i]], child[childKey[i]])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../zql/src/ivm/flipped-join.ts
+var FlippedJoin = class {
+  #parent;
+  #child;
+  #parentKey;
+  #childKey;
+  #relationshipName;
+  #schema;
+  #output = throwOutput;
+  #inprogressChildChange;
+  constructor({
+    parent,
+    child,
+    parentKey,
+    childKey,
+    relationshipName,
+    hidden,
+    system
+  }) {
+    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.#parentKey = parentKey;
+    this.#childKey = childKey;
+    this.#relationshipName = relationshipName;
+    const parentSchema = parent.getSchema();
+    const childSchema = child.getSchema();
+    this.#schema = {
+      ...parentSchema,
+      relationships: {
+        ...parentSchema.relationships,
+        [relationshipName]: {
+          ...childSchema,
+          isHidden: hidden,
+          system
+        }
+      }
+    };
+    parent.setOutput({
+      push: (change) => this.#pushParent(change)
+    });
+    child.setOutput({
+      push: (change) => this.#pushChild(change)
+    });
+  }
+  destroy() {
+    this.#child.destroy();
+    this.#parent.destroy();
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  getSchema() {
+    return this.#schema;
+  }
+  // TODO: When parentKey is the parent's primary key (or more
+  // generally when the parent cardinality is expected to be small) a different
+  // algorithm should be used:  For each child node, fetch all parent nodes
+  // eagerly and then sort using quicksort.
+  *fetch(req) {
+    const childNodes = [...this.#child.fetch({})];
+    if (this.#inprogressChildChange?.change.type === "remove") {
+      const removedNode = this.#inprogressChildChange.change.node;
+      const compare2 = this.#child.getSchema().compareRows;
+      const insertPos = binarySearch(
+        childNodes.length,
+        (i) => compare2(removedNode.row, childNodes[i].row)
+      );
+      childNodes.splice(insertPos, 0, removedNode);
+    }
+    const parentIterators = [];
+    let threw = false;
+    try {
+      for (const childNode of childNodes) {
+        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 iterator2 = stream[Symbol.iterator]();
+          parentIterators.push(iterator2);
+        }
+      }
+      const nextParentNodes = [];
+      for (let i = 0; i < parentIterators.length; i++) {
+        const iter = parentIterators[i];
+        const result = iter.next();
+        nextParentNodes[i] = result.done ? null : result.value;
+      }
+      while (true) {
+        let minParentNode = null;
+        let minParentNodeChildIndexes = [];
+        for (let i = 0; i < nextParentNodes.length; i++) {
+          const parentNode = nextParentNodes[i];
+          if (parentNode === null) {
+            continue;
+          }
+          if (minParentNode === null) {
+            minParentNode = parentNode;
+            minParentNodeChildIndexes.push(i);
+          } else {
+            const compareResult = this.#schema.compareRows(parentNode.row, minParentNode.row) * (req.reverse ? -1 : 1);
+            if (compareResult === 0) {
+              minParentNodeChildIndexes.push(i);
+            } else if (compareResult < 0) {
+              minParentNode = parentNode;
+              minParentNodeChildIndexes = [i];
+            }
+          }
+        }
+        if (minParentNode === null) {
+          return;
+        }
+        const relatedChildNodes = [];
+        for (const minParentNodeChildIndex of minParentNodeChildIndexes) {
+          relatedChildNodes.push(childNodes[minParentNodeChildIndex]);
+          const iter = parentIterators[minParentNodeChildIndex];
+          const result = iter.next();
+          nextParentNodes[minParentNodeChildIndex] = result.done ? null : result.value;
+        }
+        let overlaidRelatedChildNodes = relatedChildNodes;
+        if (this.#inprogressChildChange && this.#inprogressChildChange.position && isJoinMatch(
+          this.#inprogressChildChange.change.node.row,
+          this.#childKey,
+          minParentNode.row,
+          this.#parentKey
+        )) {
+          const hasInprogressChildChangeBeenPushedForMinParentNode = this.#parent.getSchema().compareRows(
+            minParentNode.row,
+            this.#inprogressChildChange.position
+          ) <= 0;
+          if (this.#inprogressChildChange.change.type === "remove") {
+            if (hasInprogressChildChangeBeenPushedForMinParentNode) {
+              overlaidRelatedChildNodes = relatedChildNodes.filter(
+                (n) => n !== this.#inprogressChildChange?.change.node
+              );
+            }
+          } else if (!hasInprogressChildChangeBeenPushedForMinParentNode) {
+            overlaidRelatedChildNodes = [
+              ...generateWithOverlay(
+                relatedChildNodes,
+                this.#inprogressChildChange.change,
+                this.#child.getSchema()
+              )
+            ];
+          }
+        }
+        if (overlaidRelatedChildNodes.length > 0) {
+          yield {
+            ...minParentNode,
+            relationships: {
+              ...minParentNode.relationships,
+              [this.#relationshipName]: () => overlaidRelatedChildNodes
+            }
+          };
+        }
+      }
+    } catch (e) {
+      threw = true;
+      for (const iter of parentIterators) {
+        try {
+          iter.throw?.(e);
+        } catch (_cleanupError) {
+        }
+      }
+      throw e;
+    } finally {
+      if (!threw) {
+        for (const iter of parentIterators) {
+          try {
+            iter.return?.();
+          } catch (_cleanupError) {
+          }
+        }
+      }
+    }
+  }
+  *cleanup(_req) {
+  }
+  #pushChild(change) {
+    const pushChildChange = (exists) => {
+      this.#inprogressChildChange = {
+        change,
+        position: void 0
+      };
+      try {
+        const parentNodeStream = this.#parent.fetch({
+          constraint: Object.fromEntries(
+            this.#parentKey.map((key, i) => [
+              key,
+              change.node.row[this.#childKey[i]]
+            ])
+          )
+        });
+        for (const parentNode of parentNodeStream) {
+          this.#inprogressChildChange = {
+            change,
+            position: parentNode.row
+          };
+          const childNodeStream = () => this.#child.fetch({
+            constraint: Object.fromEntries(
+              this.#childKey.map((key, i) => [
+                key,
+                parentNode.row[this.#parentKey[i]]
+              ])
+            )
+          });
+          if (!exists) {
+            for (const childNode of childNodeStream()) {
+              if (this.#child.getSchema().compareRows(childNode.row, change.node.row) !== 0) {
+                exists = true;
+                break;
+              }
+            }
+          }
+          if (exists) {
+            this.#output.push(
+              {
+                type: "child",
+                node: {
+                  ...parentNode,
+                  relationships: {
+                    ...parentNode.relationships,
+                    [this.#relationshipName]: childNodeStream
+                  }
+                },
+                child: {
+                  relationshipName: this.#relationshipName,
+                  change
+                }
+              },
+              this
+            );
+          } else {
+            this.#output.push(
+              {
+                ...change,
+                node: {
+                  ...parentNode,
+                  relationships: {
+                    ...parentNode.relationships,
+                    [this.#relationshipName]: () => [change.node]
+                  }
+                }
+              },
+              this
+            );
+          }
+        }
+      } finally {
+        this.#inprogressChildChange = void 0;
+      }
+    };
+    switch (change.type) {
+      case "add":
+      case "remove":
+        pushChildChange();
+        break;
+      case "edit": {
+        assert(
+          rowEqualsForCompoundKey(
+            change.oldNode.row,
+            change.node.row,
+            this.#childKey
+          ),
+          `Child edit must not change relationship.`
+        );
+        pushChildChange(true);
+        break;
+      }
+      case "child":
+        pushChildChange(true);
+        break;
+    }
+  }
+  #pushParent(change) {
+    const childNodeStream = (node) => () => this.#child.fetch({
+      constraint: Object.fromEntries(
+        this.#childKey.map((key, i) => [key, node.row[this.#parentKey[i]]])
+      )
+    });
+    const flip = (node) => ({
+      ...node,
+      relationships: {
+        ...node.relationships,
+        [this.#relationshipName]: childNodeStream(node)
+      }
+    });
+    if (first(childNodeStream(change.node)()) === void 0) {
+      return;
+    }
+    switch (change.type) {
+      case "add":
+      case "remove":
+      case "child": {
+        this.#output.push(
+          {
+            ...change,
+            node: flip(change.node)
+          },
+          this
+        );
+        break;
+      }
+      case "edit": {
+        assert(
+          rowEqualsForCompoundKey(
+            change.oldNode.row,
+            change.node.row,
+            this.#parentKey
+          ),
+          `Parent edit must not change relationship.`
+        );
+        this.#output.push(
+          {
+            type: "edit",
+            oldNode: flip(change.oldNode),
+            node: flip(change.node)
+          },
+          this
+        );
+        break;
+      }
+      default:
+        unreachable(change);
+    }
+  }
+};
+
+// ../zql/src/ivm/join.ts
+var Join = class {
+  #parent;
+  #child;
+  #storage;
+  #parentKey;
+  #childKey;
+  #relationshipName;
+  #schema;
+  #output = throwOutput;
+  #inprogressChildChange;
+  constructor({
+    parent,
+    child,
+    storage,
+    parentKey,
+    childKey,
+    relationshipName,
+    hidden,
+    system
+  }) {
+    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;
+    this.#parentKey = parentKey;
+    this.#childKey = childKey;
+    this.#relationshipName = relationshipName;
+    const parentSchema = parent.getSchema();
+    const childSchema = child.getSchema();
+    this.#schema = {
+      ...parentSchema,
+      relationships: {
+        ...parentSchema.relationships,
+        [relationshipName]: {
+          ...childSchema,
+          isHidden: hidden,
+          system
+        }
+      }
+    };
+    parent.setOutput({
+      push: (change) => this.#pushParent(change)
+    });
+    child.setOutput({
+      push: (change) => this.#pushChild(change)
+    });
+  }
+  destroy() {
+    this.#parent.destroy();
+    this.#child.destroy();
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  getSchema() {
+    return this.#schema;
+  }
+  *fetch(req) {
+    for (const parentNode of this.#parent.fetch(req)) {
+      yield this.#processParentNode(
+        parentNode.row,
+        parentNode.relationships,
+        "fetch"
+      );
+    }
+  }
+  *cleanup(req) {
+    for (const parentNode of this.#parent.cleanup(req)) {
+      yield this.#processParentNode(
+        parentNode.row,
+        parentNode.relationships,
+        "cleanup"
+      );
+    }
+  }
+  #pushParent(change) {
+    switch (change.type) {
+      case "add":
+        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
+        );
+        break;
+      case "child":
+        this.#output.push(
+          {
+            type: "child",
+            node: this.#processParentNode(
+              change.node.row,
+              change.node.relationships,
+              "fetch"
+            ),
+            child: change.child
+          },
+          this
+        );
+        break;
+      case "edit": {
+        assert(
+          rowEqualsForCompoundKey(
+            change.oldNode.row,
+            change.node.row,
+            this.#parentKey
+          ),
+          `Parent edit must not change relationship.`
+        );
+        this.#output.push(
+          {
+            type: "edit",
+            oldNode: this.#processParentNode(
+              change.oldNode.row,
+              change.oldNode.relationships,
+              "cleanup"
+            ),
+            node: this.#processParentNode(
+              change.node.row,
+              change.node.relationships,
+              "fetch"
+            )
+          },
+          this
+        );
+        break;
+      }
+      default:
+        unreachable(change);
+    }
+  }
+  #pushChild(change) {
+    const pushChildChange = (childRow, change2) => {
+      this.#inprogressChildChange = {
+        change: change2,
+        position: void 0
+      };
+      try {
+        const parentNodes = this.#parent.fetch({
+          constraint: Object.fromEntries(
+            this.#parentKey.map((key, i) => [key, childRow[this.#childKey[i]]])
+          )
+        });
+        for (const parentNode of parentNodes) {
+          this.#inprogressChildChange.position = parentNode.row;
+          const childChange = {
+            type: "child",
+            node: this.#processParentNode(
+              parentNode.row,
+              parentNode.relationships,
+              "fetch"
+            ),
+            child: {
+              relationshipName: this.#relationshipName,
+              change: change2
+            }
+          };
+          this.#output.push(childChange, this);
+        }
+      } finally {
+        this.#inprogressChildChange = void 0;
+      }
+    };
+    switch (change.type) {
+      case "add":
+      case "remove":
+        pushChildChange(change.node.row, change);
+        break;
+      case "child":
+        pushChildChange(change.node.row, change);
+        break;
+      case "edit": {
+        const childRow = change.node.row;
+        const oldChildRow = change.oldNode.row;
+        assert(
+          rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey),
+          "Child edit must not change relationship."
+        );
+        pushChildChange(childRow, change);
+        break;
+      }
+      default:
+        unreachable(change);
+    }
+  }
+  #processParentNode(parentNodeRow, parentNodeRelations, mode) {
+    let method = mode;
+    let storageUpdated = false;
+    const childStream = () => {
+      if (!storageUpdated) {
+        if (mode === "cleanup") {
+          this.#storage.del(
+            makeStorageKey(
+              this.#parentKey,
+              this.#parent.getSchema().primaryKey,
+              parentNodeRow
+            )
+          );
+          const empty = [
+            ...take(
+              this.#storage.scan({
+                prefix: makeStorageKeyPrefix(parentNodeRow, this.#parentKey)
+              }),
+              1
+            )
+          ].length === 0;
+          method = empty ? "cleanup" : "fetch";
+        }
+        storageUpdated = true;
+        if (mode === "fetch") {
+          this.#storage.set(
+            makeStorageKey(
+              this.#parentKey,
+              this.#parent.getSchema().primaryKey,
+              parentNodeRow
+            ),
+            true
+          );
+        }
+      }
+      const stream = this.#child[method]({
+        constraint: Object.fromEntries(
+          this.#childKey.map((key, i) => [
+            key,
+            parentNodeRow[this.#parentKey[i]]
+          ])
+        )
+      });
+      if (this.#inprogressChildChange && isJoinMatch(
+        parentNodeRow,
+        this.#parentKey,
+        this.#inprogressChildChange.change.node.row,
+        this.#childKey
+      ) && this.#inprogressChildChange.position && this.#schema.compareRows(
+        parentNodeRow,
+        this.#inprogressChildChange.position
+      ) > 0) {
+        return generateWithOverlay(
+          stream,
+          this.#inprogressChildChange.change,
+          this.#child.getSchema()
+        );
+      }
+      return stream;
+    };
+    return {
+      row: parentNodeRow,
+      relationships: {
+        ...parentNodeRelations,
+        [this.#relationshipName]: childStream
+      }
+    };
+  }
+};
+function makeStorageKeyForValues(values) {
+  const json2 = JSON.stringify(["pKeySet", ...values]);
+  return json2.substring(1, json2.length - 1) + ",";
+}
+function makeStorageKeyPrefix(row, key) {
+  return makeStorageKeyForValues(key.map((k) => row[k]));
+}
+function makeStorageKey(key, primaryKey, row) {
+  const values = key.map((k) => row[k]);
+  for (const key2 of primaryKey) {
+    values.push(row[key2]);
+  }
+  return makeStorageKeyForValues(values);
+}
+
+// ../zql/src/ivm/skip.ts
+var Skip = class {
+  #input;
+  #bound;
+  #comparator;
+  #output = throwOutput;
+  constructor(input, bound) {
+    this.#input = input;
+    this.#bound = bound;
+    this.#comparator = input.getSchema().compareRows;
+    input.setOutput(this);
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  fetch(req) {
+    return this.#fetchOrCleanup("fetch", req);
+  }
+  cleanup(req) {
+    return this.#fetchOrCleanup("fetch", req);
+  }
+  *#fetchOrCleanup(method, req) {
+    const start = this.#getStart(req);
+    if (start === "empty") {
+      return;
+    }
+    const nodes = this.#input[method]({ ...req, start });
+    if (!req.reverse) {
+      yield* nodes;
+      return;
+    }
+    for (const node of nodes) {
+      if (!this.#shouldBePresent(node.row)) {
+        return;
+      }
+      yield node;
+    }
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  #shouldBePresent(row) {
+    const cmp2 = this.#comparator(this.#bound.row, row);
+    return cmp2 < 0 || cmp2 === 0 && !this.#bound.exclusive;
+  }
+  push(change) {
+    const shouldBePresent = (row) => this.#shouldBePresent(row);
+    if (change.type === "edit") {
+      maybeSplitAndPushEditChange(change, shouldBePresent, this.#output, this);
+      return;
+    }
+    change;
+    if (shouldBePresent(change.node.row)) {
+      this.#output.push(change, this);
+    }
+  }
+  #getStart(req) {
+    const boundStart = {
+      row: this.#bound.row,
+      basis: this.#bound.exclusive ? "after" : "at"
+    };
+    if (!req.start) {
+      if (req.reverse) {
+        return void 0;
+      }
+      return boundStart;
+    }
+    const cmp2 = this.#comparator(this.#bound.row, req.start.row);
+    if (!req.reverse) {
+      if (cmp2 > 0) {
+        return boundStart;
+      }
+      if (cmp2 === 0) {
+        if (this.#bound.exclusive || req.start.basis === "after") {
+          return {
+            row: this.#bound.row,
+            basis: "after"
+          };
+        }
+        return boundStart;
+      }
+      return req.start;
+    }
+    req.reverse;
+    if (cmp2 > 0) {
+      return "empty";
+    }
+    if (cmp2 === 0) {
+      if (!this.#bound.exclusive && req.start.basis === "at") {
+        return boundStart;
+      }
+      return "empty";
+    }
+    return req.start;
+  }
+};
+
+// ../zql/src/ivm/take.ts
+var MAX_BOUND_KEY = "maxBound";
+var Take = class {
+  #input;
+  #storage;
+  #limit;
+  #partitionKey;
+  #partitionKeyComparator;
+  // Fetch overlay needed for some split push cases.
+  #rowHiddenFromFetch;
+  #output = throwOutput;
+  constructor(input, storage, limit, 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;
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  *fetch(req) {
+    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);
+        return;
+      }
+      if (takeState.bound === void 0) {
+        return;
+      }
+      for (const inputNode of this.#input.fetch(req)) {
+        if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {
+          return;
+        }
+        if (this.#rowHiddenFromFetch && this.getSchema().compareRows(
+          this.#rowHiddenFromFetch,
+          inputNode.row
+        ) === 0) {
+          continue;
+        }
+        yield inputNode;
+      }
+      return;
+    }
+    const maxBound = this.#storage.get(MAX_BOUND_KEY);
+    if (maxBound === void 0) {
+      return;
+    }
+    for (const inputNode of this.#input.fetch(req)) {
+      if (this.getSchema().compareRows(inputNode.row, maxBound) > 0) {
+        return;
+      }
+      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;
+      }
+    }
+  }
+  *#initialFetch(req) {
+    assert(req.start === void 0);
+    assert(!req.reverse);
+    assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey));
+    if (this.#limit === 0) {
+      return;
+    }
+    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
+    assert(this.#storage.get(takeStateKey) === void 0);
+    let size = 0;
+    let bound;
+    let downstreamEarlyReturn = true;
+    let exceptionThrown = false;
+    try {
+      for (const inputNode of this.#input.fetch(req)) {
+        yield inputNode;
+        bound = inputNode.row;
+        size++;
+        if (size === this.#limit) {
+          break;
+        }
+      }
+      downstreamEarlyReturn = false;
+    } catch (e) {
+      exceptionThrown = true;
+      throw e;
+    } finally {
+      if (!exceptionThrown) {
+        this.#setTakeState(
+          takeStateKey,
+          size,
+          bound,
+          this.#storage.get(MAX_BOUND_KEY)
+        );
+        assert(
+          !downstreamEarlyReturn,
+          "Unexpected early return prevented full hydration"
+        );
+      }
+    }
+  }
+  *cleanup(req) {
+    assert(req.start === void 0);
+    assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey));
+    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
+    this.#storage.del(takeStateKey);
+    let size = 0;
+    for (const inputNode of this.#input.cleanup(req)) {
+      if (size === this.#limit) {
+        return;
+      }
+      size++;
+      yield inputNode;
+    }
+  }
+  #getStateAndConstraint(row) {
+    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 && Object.fromEntries(
+        this.#partitionKey.map((key) => [key, row[key]])
+      );
+    }
+    return { takeState, takeStateKey, maxBound, constraint };
+  }
+  push(change) {
+    if (change.type === "edit") {
+      this.#pushEditChange(change);
+      return;
+    }
+    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.node.row);
+    if (!takeState) {
+      return;
+    }
+    const { compareRows } = this.getSchema();
+    if (change.type === "add") {
+      if (takeState.size < this.#limit) {
+        this.#setTakeState(
+          takeStateKey,
+          takeState.size + 1,
+          takeState.bound === void 0 || compareRows(takeState.bound, change.node.row) < 0 ? change.node.row : takeState.bound,
+          maxBound
+        );
+        this.#output.push(change, this);
+        return;
+      }
+      if (takeState.bound === void 0 || compareRows(change.node.row, takeState.bound) >= 0) {
+        return;
+      }
+      let beforeBoundNode;
+      let boundNode;
+      if (this.#limit === 1) {
+        boundNode = must(
+          first(
+            this.#input.fetch({
+              start: {
+                row: takeState.bound,
+                basis: "at"
+              },
+              constraint
+            })
+          )
+        );
+      } else {
+        [boundNode, beforeBoundNode] = take(
+          this.#input.fetch({
+            start: {
+              row: takeState.bound,
+              basis: "at"
+            },
+            constraint,
+            reverse: true
+          }),
+          2
+        );
+      }
+      const removeChange = {
+        type: "remove",
+        node: boundNode
+      };
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        beforeBoundNode === void 0 || compareRows(change.node.row, beforeBoundNode.row) > 0 ? change.node.row : beforeBoundNode.row,
+        maxBound
+      );
+      this.#withRowHiddenFromFetch(change.node.row, () => {
+        this.#output.push(removeChange, this);
+      });
+      this.#output.push(change, this);
+    } else if (change.type === "remove") {
+      if (takeState.bound === void 0) {
+        return;
+      }
+      const compToBound = compareRows(change.node.row, takeState.bound);
+      if (compToBound > 0) {
+        return;
+      }
+      const [beforeBoundNode] = take(
+        this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "after"
+          },
+          constraint,
+          reverse: true
+        }),
+        1
+      );
+      let newBound;
+      if (beforeBoundNode) {
+        const push2 = compareRows(beforeBoundNode.row, takeState.bound) > 0;
+        newBound = {
+          node: beforeBoundNode,
+          push: push2
+        };
+      }
+      if (!newBound?.push) {
+        for (const node of this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "at"
+          },
+          constraint
+        })) {
+          const push2 = compareRows(node.row, takeState.bound) > 0;
+          newBound = {
+            node,
+            push: push2
+          };
+          if (push2) {
+            break;
+          }
+        }
+      }
+      if (newBound?.push) {
+        this.#output.push(change, this);
+        this.#setTakeState(
+          takeStateKey,
+          takeState.size,
+          newBound.node.row,
+          maxBound
+        );
+        this.#output.push(
+          {
+            type: "add",
+            node: newBound.node
+          },
+          this
+        );
+        return;
+      }
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size - 1,
+        newBound?.node.row,
+        maxBound
+      );
+      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);
+      }
+    }
+  }
+  #pushEditChange(change) {
+    assert(
+      !this.#partitionKeyComparator || this.#partitionKeyComparator(change.oldNode.row, change.node.row) === 0,
+      "Unexpected change of partition key"
+    );
+    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.oldNode.row);
+    if (!takeState) {
+      return;
+    }
+    assert(takeState.bound, "Bound should be set");
+    const { compareRows } = this.getSchema();
+    const oldCmp = compareRows(change.oldNode.row, takeState.bound);
+    const newCmp = compareRows(change.node.row, takeState.bound);
+    const replaceBoundAndForwardChange = () => {
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        change.node.row,
+        maxBound
+      );
+      this.#output.push(change, this);
+    };
+    if (oldCmp === 0) {
+      if (newCmp === 0) {
+        this.#output.push(change, this);
+        return;
+      }
+      if (newCmp < 0) {
+        if (this.#limit === 1) {
+          replaceBoundAndForwardChange();
+          return;
+        }
+        const beforeBoundNode = must(
+          first(
+            this.#input.fetch({
+              start: {
+                row: takeState.bound,
+                basis: "after"
+              },
+              constraint,
+              reverse: true
+            })
+          )
+        );
+        this.#setTakeState(
+          takeStateKey,
+          takeState.size,
+          beforeBoundNode.row,
+          maxBound
+        );
+        this.#output.push(change, this);
+        return;
+      }
+      assert(newCmp > 0);
+      const newBoundNode = must(
+        first(
+          this.#input.fetch({
+            start: {
+              row: takeState.bound,
+              basis: "at"
+            },
+            constraint
+          })
+        )
+      );
+      if (compareRows(newBoundNode.row, change.node.row) === 0) {
+        replaceBoundAndForwardChange();
+        return;
+      }
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        newBoundNode.row,
+        maxBound
+      );
+      this.#withRowHiddenFromFetch(newBoundNode.row, () => {
+        this.#output.push(
+          {
+            type: "remove",
+            node: change.oldNode
+          },
+          this
+        );
+      });
+      this.#output.push(
+        {
+          type: "add",
+          node: newBoundNode
+        },
+        this
+      );
+      return;
+    }
+    if (oldCmp > 0) {
+      assert(newCmp !== 0, "Invalid state. Row has duplicate primary key");
+      if (newCmp > 0) {
+        return;
+      }
+      assert(newCmp < 0);
+      const [oldBoundNode, newBoundNode] = take(
+        this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "at"
+          },
+          constraint,
+          reverse: true
+        }),
+        2
+      );
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        newBoundNode.row,
+        maxBound
+      );
+      this.#withRowHiddenFromFetch(change.node.row, () => {
+        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);
+        return;
+      }
+      assert(newCmp > 0);
+      const afterBoundNode = must(
+        first(
+          this.#input.fetch({
+            start: {
+              row: takeState.bound,
+              basis: "after"
+            },
+            constraint
+          })
+        )
+      );
+      if (compareRows(afterBoundNode.row, change.node.row) === 0) {
+        replaceBoundAndForwardChange();
+        return;
+      }
+      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
+      );
+      return;
+    }
+    unreachable();
+  }
+  #withRowHiddenFromFetch(row, fn) {
+    this.#rowHiddenFromFetch = row;
+    try {
+      fn();
+    } finally {
+      this.#rowHiddenFromFetch = void 0;
+    }
+  }
+  #setTakeState(takeStateKey, size, bound, maxBound) {
+    this.#storage.set(takeStateKey, {
+      size,
+      bound
+    });
+    if (bound !== void 0 && (maxBound === void 0 || this.getSchema().compareRows(bound, maxBound) > 0)) {
+      this.#storage.set(MAX_BOUND_KEY, bound);
+    }
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+};
+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) {
+  if (constraint === void 0 || partitionKey === void 0) {
+    return constraint === partitionKey;
+  }
+  if (partitionKey.length !== Object.keys(constraint).length) {
+    return false;
+  }
+  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/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;
+  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: isParameterReference(left) ? left[toStaticParam]() : { type: "literal", value: left },
+      right: isParameterReference(right) ? right[toStaticParam]() : { type: "literal", value: right },
+      op
+    };
+  }
+  and = and;
+  or = or;
+  not = not;
+  exists = (relationship, cb, options) => this.#exists(relationship, cb, options);
+};
+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: isParameterReference(value) ? value[toStaticParam]() : { type: "literal", value },
+    op
+  };
+}
+function isParameterReference(value) {
+  return value !== null && typeof value === "object" && value[toStaticParam];
+}
+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 simplifyCondition(c) {
+  if (c.type === "simple" || c.type === "correlatedSubquery") {
+    return c;
+  }
+  if (c.conditions.length === 1) {
+    return simplifyCondition(c.conditions[0]);
+  }
+  const conditions = flatten(c.type, c.conditions.map(simplifyCondition));
+  if (c.type === "and" && conditions.some(isAlwaysFalse)) {
+    return FALSE;
+  }
+  if (c.type === "or" && conditions.some(isAlwaysTrue)) {
+    return TRUE;
+  }
+  return {
+    type: c.type,
+    conditions
+  };
+}
+function flatten(type, conditions) {
+  const flattened = [];
+  for (const c of conditions) {
+    if (c.type === type) {
+      flattened.push(...c.conditions);
+    } else {
+      flattened.push(c);
+    }
+  }
+  return flattened;
+}
+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/builder/like.ts
+function getLikePredicate(pattern, flags) {
+  const op = getLikeOp(String(pattern), flags);
+  return (lhs) => {
+    assertString(lhs);
+    return op(String(lhs));
+  };
+}
+function getLikeOp(pattern, flags) {
+  if (!/_|%|\\/.test(pattern)) {
+    if (flags === "i") {
+      const rhsLower = pattern.toLowerCase();
+      return (lhs) => lhs.toLowerCase() === rhsLower;
+    }
+    return (lhs) => lhs === pattern;
+  }
+  const re = patternToRegExp(pattern, flags);
+  return (lhs) => re.test(lhs);
+}
+var specialCharsRe = /[$()*+.?[\]\\^{|}]/;
+function patternToRegExp(source, flags = "") {
+  let pattern = "^";
+  for (let i = 0; i < source.length; i++) {
+    let c = source[i];
+    switch (c) {
+      case "%":
+        pattern += ".*";
+        break;
+      case "_":
+        pattern += ".";
+        break;
+      // @ts-expect-error fallthrough
+      case "\\":
+        if (i === source.length - 1) {
+          throw new Error("LIKE pattern must not end with escape character");
+        }
+        i++;
+        c = source[i];
+      // fall through
+      default:
+        if (specialCharsRe.test(c)) {
+          pattern += "\\";
+        }
+        pattern += c;
+        break;
+    }
+  }
+  return new RegExp(pattern + "$", flags + "m");
+}
+
+// ../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(
+    right.type !== "static",
+    "static values should be resolved before creating predicates"
+  );
+  assert(
+    left.type !== "static",
+    "static values should be resolved before creating predicates"
+  );
+  switch (condition.op) {
+    case "IS":
+    case "IS NOT": {
+      const impl2 = createIsPredicate(right.value, condition.op);
+      if (left.type === "literal") {
+        const result = impl2(left.value);
+        return () => result;
+      }
+      return (row) => impl2(row[left.name]);
+    }
+  }
+  if (right.value === null || right.value === void 0) {
+    return (_row) => false;
+  }
+  const impl = createPredicateImpl(right.value, condition.op);
+  if (left.type === "literal") {
+    if (left.value === null || left.value === void 0) {
+      return (_row) => false;
+    }
+    const result = impl(left.value);
+    return () => result;
+  }
+  return (row) => {
+    const lhs = row[left.name];
+    if (lhs === null || lhs === void 0) {
+      return false;
+    }
+    return impl(lhs);
+  };
+}
+function createIsPredicate(rhs, operator) {
+  switch (operator) {
+    case "IS":
+      return (lhs) => lhs === rhs;
+    case "IS NOT":
+      return (lhs) => lhs !== rhs;
+  }
+}
+function createPredicateImpl(rhs, operator) {
+  switch (operator) {
+    case "=":
+      return (lhs) => lhs === rhs;
+    case "!=":
+      return (lhs) => lhs !== rhs;
+    case "<":
+      return (lhs) => lhs < rhs;
+    case "<=":
+      return (lhs) => lhs <= rhs;
+    case ">":
+      return (lhs) => lhs > rhs;
+    case ">=":
+      return (lhs) => lhs >= rhs;
+    case "LIKE":
+      return getLikePredicate(rhs, "");
+    case "NOT LIKE":
+      return not2(getLikePredicate(rhs, ""));
+    case "ILIKE":
+      return getLikePredicate(rhs, "i");
+    case "NOT ILIKE":
+      return not2(getLikePredicate(rhs, "i"));
+    case "IN": {
+      assert(Array.isArray(rhs));
+      const set = new Set(rhs);
+      return (lhs) => set.has(lhs);
+    }
+    case "NOT IN": {
+      assert(Array.isArray(rhs));
+      const set = new Set(rhs);
+      return (lhs) => !set.has(lhs);
+    }
+    default:
+      operator;
+      throw new Error(`Unexpected operator: ${operator}`);
+  }
+}
+function not2(f) {
+  return (lhs) => !f(lhs);
+}
+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":
+    case "or": {
+      const transformedConditions = [];
+      let conditionsRemoved = false;
+      for (const cond of filters.conditions) {
+        const transformed = transformFilters(cond);
+        if (transformed.filters === void 0 && filters.type === "or") {
+          return { filters: void 0, conditionsRemoved: true };
+        }
+        conditionsRemoved = conditionsRemoved || transformed.conditionsRemoved;
+        if (transformed.filters) {
+          transformedConditions.push(transformed.filters);
+        }
+      }
+      return {
+        filters: simplifyCondition({
+          type: filters.type,
+          conditions: transformedConditions
+        }),
+        conditionsRemoved
+      };
+    }
+    default:
+      unreachable(filters);
+  }
+}
+
+// ../zql/src/builder/builder.ts
+function buildPipeline(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 csqConditions = gatherCorrelatedSubqueryQueryConditions(ast.where);
+  const splitEditKeys = partitionKey ? new Set(partitionKey) : /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Set();
+  for (const csq of csqConditions) {
+    aliases.add(csq.related.subquery.alias || "");
+    for (const key of csq.related.correlation.parentField) {
+      splitEditKeys.add(key);
+    }
+  }
+  if (ast.related) {
+    for (const csq of ast.related) {
+      for (const key of csq.correlation.parentField) {
+        splitEditKeys.add(key);
+      }
+    }
+  }
+  const conn = source.connect(
+    must(ast.orderBy),
+    ast.where,
+    splitEditKeys,
+    delegate.debug
+  );
+  let end = delegate.decorateSourceInput(conn, queryID);
+  end = delegate.decorateInput(end, `${name}:source(${ast.table})`);
+  const { fullyAppliedFilters } = conn;
+  if (ast.start) {
+    const skip = new Skip(end, ast.start);
+    delegate.addEdge(end, skip);
+    end = delegate.decorateInput(skip, `${name}:skip)`);
+  }
+  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);
+  }
+  if (ast.limit !== void 0) {
+    const takeName = `${name}:take`;
+    const take2 = new Take(
+      end,
+      delegate.createStorage(takeName),
+      ast.limit,
+      partitionKey
+    );
+    delegate.addEdge(end, take2);
+    end = delegate.decorateInput(take2, takeName);
+  }
+  if (ast.related) {
+    for (const csq of ast.related) {
+      end = applyCorrelatedSubQuery(csq, delegate, queryID, end, name, false);
+    }
+  }
+  return end;
+}
+function applyWhere(input, 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) {
+    case "and":
+      return applyAnd(input, condition, delegate, name);
+    case "or":
+      return applyOr(input, condition, delegate, name);
+    case "correlatedSubquery":
+      return applyCorrelatedSubqueryCondition(input, condition, delegate, name);
+    case "simple":
+      return applySimpleCondition(input, delegate, condition);
+  }
+}
+function applyAnd(input, condition, delegate, name) {
+  for (const subCondition of condition.conditions) {
+    input = applyFilter(input, subCondition, delegate, name);
+  }
+  return input;
+}
+function applyOr(input, condition, delegate, name) {
+  const [subqueryConditions, otherConditions] = groupSubqueryConditions(condition);
+  if (subqueryConditions.length === 0) {
+    const filter = new Filter(
+      input,
+      createPredicate({
+        type: "or",
+        conditions: otherConditions
+      })
+    );
+    delegate.addEdge(input, filter);
+    return filter;
+  }
+  const fanOut = new FanOut(input);
+  delegate.addEdge(input, fanOut);
+  const branches = subqueryConditions.map(
+    (subCondition) => applyFilter(fanOut, subCondition, delegate, name)
+  );
+  if (otherConditions.length > 0) {
+    const filter = new Filter(
+      fanOut,
+      createPredicate({
+        type: "or",
+        conditions: otherConditions
+      })
+    );
+    delegate.addEdge(fanOut, filter);
+    branches.push(filter);
+  }
+  const ret = new FanIn(fanOut, branches);
+  for (const branch of branches) {
+    delegate.addEdge(branch, ret);
+  }
+  fanOut.setFanIn(ret);
+  return ret;
+}
+function groupSubqueryConditions(condition) {
+  const partitioned = [[], []];
+  for (const subCondition of condition.conditions) {
+    if (isNotAndDoesNotContainSubquery(subCondition)) {
+      partitioned[1].push(subCondition);
+    } else {
+      partitioned[0].push(subCondition);
+    }
+  }
+  return partitioned;
+}
+function isNotAndDoesNotContainSubquery(condition) {
+  if (condition.type === "correlatedSubquery") {
+    return false;
+  }
+  if (condition.type === "simple") {
+    return true;
+  }
+  return condition.conditions.every(isNotAndDoesNotContainSubquery);
+}
+function applySimpleCondition(input, delegate, condition) {
+  const filter = new Filter(input, createPredicate(condition));
+  delegate.decorateFilterInput(
+    filter,
+    `${valuePosName(condition.left)}:${condition.op}:${valuePosName(condition.right)}`
+  );
+  delegate.addEdge(input, filter);
+  return filter;
+}
+function valuePosName(left) {
+  switch (left.type) {
+    case "static":
+      return left.field;
+    case "literal":
+      return left.value;
+    case "column":
+      return left.name;
+  }
+}
+function applyCorrelatedSubQuery(sq, delegate, queryID, end, name, fromCondition) {
+  if (sq.subquery.limit === 0 && fromCondition) {
+    return end;
+  }
+  assert(sq.subquery.alias, "Subquery must have an alias");
+  const child = buildPipelineInternal(
+    sq.subquery,
+    delegate,
+    queryID,
+    `${name}.${sq.subquery.alias}`,
+    sq.correlation.childField
+  );
+  const joinName = `${name}:join(${sq.subquery.alias})`;
+  const join = new Join({
+    parent: end,
+    child,
+    storage: delegate.createStorage(joinName),
+    parentKey: sq.correlation.parentField,
+    childKey: sq.correlation.childField,
+    relationshipName: sq.subquery.alias,
+    hidden: sq.hidden ?? false,
+    system: sq.system ?? "client"
+  });
+  delegate.addEdge(end, join);
+  delegate.addEdge(child, join);
+  return delegate.decorateInput(join, joinName);
+}
+function applyCorrelatedSubqueryCondition(input, condition, delegate, name) {
+  assert(condition.op === "EXISTS" || condition.op === "NOT EXISTS");
+  if (condition.related.subquery.limit === 0) {
+    if (condition.op === "EXISTS") {
+      const filter2 = new Filter(input, () => false);
+      delegate.addEdge(input, filter2);
+      return filter2;
+    }
+    const filter = new Filter(input, () => true);
+    delegate.addEdge(input, filter);
+    return filter;
+  }
+  const existsName = `${name}:exists(${condition.related.subquery.alias})`;
+  const exists = new Exists(
+    input,
+    delegate.createStorage(existsName),
+    must(condition.related.subquery.alias),
+    condition.related.correlation.parentField,
+    condition.op
+  );
+  delegate.addEdge(input, exists);
+  return delegate.decorateFilterInput(exists, existsName);
+}
+function gatherCorrelatedSubqueryQueryConditions(condition) {
+  const csqs = [];
+  const gather = (condition2) => {
+    if (condition2.type === "correlatedSubquery") {
+      csqs.push(condition2);
+      return;
+    }
+    if (condition2.type === "and" || condition2.type === "or") {
+      for (const c of condition2.conditions) {
+        gather(c);
+      }
+      return;
+    }
+  };
+  if (condition) {
+    gather(condition);
+  }
+  return csqs;
+}
+function assertOrderingIncludesPK(ordering, pk) {
+  const orderingFields = ordering.map(([field]) => field);
+  const missingFields = pk.filter((pkField) => !orderingFields.includes(pkField));
+  if (missingFields.length > 0) {
+    throw new Error(
+      `Ordering must include all primary key fields. Missing: ${missingFields.join(
+        ", "
+      )}. ZQL automatically appends primary key fields to the ordering if they are missing 
+      so a common cause of this error is a casing mismatch between Postgres and ZQL.
+      E.g., "userid" vs "userID".
+      You may want to add double-quotes around your Postgres column names to prevent Postgres from lower-casing them:
+      https://www.postgresql.org/docs/current/sql-syntax-lexical.htm`
+    );
+  }
+}
+function uniquifyCorrelatedSubqueryConditionAliases(ast) {
+  if (!ast.where) {
+    return ast;
+  }
+  const { where } = ast;
+  if (where.type !== "and" && where.type !== "or") {
+    return ast;
+  }
+  let count = 0;
+  const uniquifyCorrelatedSubquery = (csqc) => ({
+    ...csqc,
+    related: {
+      ...csqc.related,
+      subquery: {
+        ...csqc.related.subquery,
+        alias: (csqc.related.subquery.alias ?? "") + "_" + count++
+      }
+    }
+  });
+  const uniquify = (cond) => {
+    if (cond.type === "simple") {
+      return cond;
+    } else if (cond.type === "correlatedSubquery") {
+      return uniquifyCorrelatedSubquery(cond);
+    }
+    const conditions = [];
+    for (const c of cond.conditions) {
+      conditions.push(uniquify(c));
+    }
+    return {
+      type: cond.type,
+      conditions
+    };
+  };
+  const result = {
+    ...ast,
+    where: uniquify(where)
+  };
+  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 {
+  constructor(message) {
+    super(message);
+    this.name = "NotImplementedError";
+  }
+};
+
+// ../zql/src/ivm/array-view.ts
+var ArrayView = class {
+  #input;
+  #listeners = /* @__PURE__ */ new Set();
+  #schema;
+  #format;
+  // Synthetic "root" entry that has a single "" relationship, so that we can
+  // treat all changes, including the root change, generically.
+  #root;
+  onDestroy;
+  #dirty = false;
+  #resultType = "unknown";
+  #error;
+  #updateTTL;
+  constructor(input, format, queryComplete, updateTTL) {
+    this.#input = input;
+    this.#schema = input.getSchema();
+    this.#format = format;
+    this.#updateTTL = updateTTL;
+    this.#root = { "": format.singular ? void 0 : [] };
+    input.setOutput(this);
+    if (queryComplete === true) {
+      this.#resultType = "complete";
+    } else if ("error" in queryComplete) {
+      this.#resultType = "error";
+      this.#error = queryComplete;
+    } else {
+      void queryComplete.then(() => {
+        this.#resultType = "complete";
+        this.#fireListeners();
+      }).catch((e) => {
+        this.#resultType = "error";
+        this.#error = e;
+        this.#fireListeners();
+      });
+    }
+    this.#hydrate();
+  }
+  get data() {
+    return this.#root[""];
+  }
+  addListener(listener) {
+    assert(!this.#listeners.has(listener), "Listener already registered");
+    this.#listeners.add(listener);
+    this.#fireListener(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  #fireListeners() {
+    for (const listener of this.#listeners) {
+      this.#fireListener(listener);
+    }
+  }
+  #fireListener(listener) {
+    listener(this.data, this.#resultType, this.#error);
+  }
+  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();
+  }
+  updateTTL(ttl) {
+    this.#updateTTL(ttl);
+  }
+};
+
+// ../zero-types/src/format.ts
+var defaultFormat = {
+  singular: false,
+  relationships: {}
+};
+
+// ../zql/src/query/assert-no-not-exists.ts
+function assertNoNotExists(condition) {
+  switch (condition.type) {
+    case "simple":
+      return;
+    case "correlatedSubquery":
+      if (condition.op === "NOT EXISTS") {
+        throw new Error(
+          "not(exists()) is not supported on the client - see https://bugs.rocicorp.dev/issue/3438"
+        );
+      }
+      if (condition.related.subquery.where) {
+        assertNoNotExists(condition.related.subquery.where);
+      }
+      return;
+    case "and":
+    case "or":
+      for (const c of condition.conditions) {
+        assertNoNotExists(c);
+      }
+      return;
+    default:
+      unreachable(condition);
+  }
+}
+
+// ../zql/src/query/query.ts
+var delegateSymbol = Symbol("delegate");
+
+// ../zql/src/query/query-impl.ts
+function materialize(query, delegate, factoryOrOptions, maybeOptions) {
+  if (typeof factoryOrOptions === "function") {
+    return query[delegateSymbol](delegate).materialize(factoryOrOptions, maybeOptions?.ttl);
+  }
+  return query[delegateSymbol](delegate).materialize(factoryOrOptions?.ttl);
+}
+var astSymbol = Symbol();
+function newQuery(delegate, schema, table2) {
+  return new QueryImpl(
+    delegate,
+    schema,
+    table2,
+    { table: table2 },
+    defaultFormat,
+    void 0
+  );
+}
+var newQuerySymbol = Symbol();
+var AbstractQuery = class {
+  #schema;
+  _delegate;
+  #tableName;
+  _ast;
+  format;
+  #hash = "";
+  #system;
+  #currentJunction;
+  customQueryID;
+  constructor(delegate, schema, tableName, ast, format, system, customQueryID, currentJunction) {
+    this.#schema = schema;
+    this._delegate = delegate;
+    this.#tableName = tableName;
+    this._ast = ast;
+    this.format = format;
+    this.#system = system;
+    this.#currentJunction = currentJunction;
+    this.customQueryID = customQueryID;
+  }
+  [delegateSymbol](delegate) {
+    return this[newQuerySymbol](
+      delegate,
+      this.#schema,
+      this.#tableName,
+      this._ast,
+      this.format,
+      this.customQueryID,
+      this.#currentJunction
+    );
+  }
+  nameAndArgs(name, args) {
+    return this[newQuerySymbol](
+      this._delegate,
+      this.#schema,
+      this.#tableName,
+      this._ast,
+      this.format,
+      {
+        name,
+        args
+      },
+      this.#currentJunction
+    );
+  }
+  get [astSymbol]() {
+    return this._ast;
+  }
+  get ast() {
+    return this._completeAst();
+  }
+  hash() {
+    if (!this.#hash) {
+      this.#hash = hashOfAST(this._completeAst());
+    }
+    return this.#hash;
+  }
+  one = () => this[newQuerySymbol](
+    this._delegate,
+    this.#schema,
+    this.#tableName,
+    {
+      ...this._ast,
+      limit: 1
+    },
+    {
+      ...this.format,
+      singular: true
+    },
+    this.customQueryID,
+    this.#currentJunction
+  );
+  whereExists = (relationship, cbOrOptions, options) => {
+    const cb = typeof cbOrOptions === "function" ? cbOrOptions : void 0;
+    const opts = typeof cbOrOptions === "function" ? options : cbOrOptions;
+    const flipped = opts?.flip ?? false;
+    return this.where(({ exists }) => exists(relationship, cb, { flip: flipped }));
+  };
+  related = (relationship, cb) => {
+    if (relationship.startsWith(SUBQ_PREFIX)) {
+      throw new Error(
+        `Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`
+      );
+    }
+    cb = cb ?? ((q) => q);
+    const related = this.#schema.relationships[this.#tableName][relationship];
+    assert(related, "Invalid relationship");
+    if (isOneHop(related)) {
+      const { destSchema, destField, sourceField, cardinality } = related[0];
+      const q = this[newQuerySymbol](
+        this._delegate,
+        this.#schema,
+        destSchema,
+        {
+          table: destSchema,
+          alias: relationship
+        },
+        {
+          relationships: {},
+          singular: cardinality === "one"
+        },
+        this.customQueryID,
+        void 0
+      );
+      const sq = cb(q);
+      assert(
+        isCompoundKey(sourceField),
+        "The source of a relationship must specify at last 1 field"
+      );
+      assert(
+        isCompoundKey(destField),
+        "The destination of a relationship must specify at last 1 field"
+      );
+      assert(
+        sourceField.length === destField.length,
+        "The source and destination of a relationship must have the same number of fields"
+      );
+      return this[newQuerySymbol](
+        this._delegate,
+        this.#schema,
+        this.#tableName,
+        {
+          ...this._ast,
+          related: [
+            ...this._ast.related ?? [],
+            {
+              system: this.#system,
+              correlation: {
+                parentField: sourceField,
+                childField: destField
+              },
+              subquery: addPrimaryKeysToAst(
+                this.#schema.tables[destSchema],
+                sq._ast
+              )
+            }
+          ]
+        },
+        {
+          ...this.format,
+          relationships: {
+            ...this.format.relationships,
+            [relationship]: sq.format
+          }
+        },
+        this.customQueryID,
+        this.#currentJunction
+      );
+    }
+    if (isTwoHop(related)) {
+      const [firstRelation, secondRelation] = related;
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
+      const sq = cb(
+        this[newQuerySymbol](
+          this._delegate,
+          this.#schema,
+          destSchema,
+          {
+            table: destSchema,
+            alias: relationship
+          },
+          {
+            relationships: {},
+            singular: secondRelation.cardinality === "one"
+          },
+          this.customQueryID,
+          relationship
+        )
+      );
+      assert(isCompoundKey(firstRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(firstRelation.destField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
+      return this[newQuerySymbol](
+        this._delegate,
+        this.#schema,
+        this.#tableName,
+        {
+          ...this._ast,
+          related: [
+            ...this._ast.related ?? [],
+            {
+              system: this.#system,
+              correlation: {
+                parentField: firstRelation.sourceField,
+                childField: firstRelation.destField
+              },
+              hidden: true,
+              subquery: {
+                table: junctionSchema,
+                alias: relationship,
+                orderBy: addPrimaryKeys(
+                  this.#schema.tables[junctionSchema],
+                  void 0
+                ),
+                related: [
+                  {
+                    system: this.#system,
+                    correlation: {
+                      parentField: secondRelation.sourceField,
+                      childField: secondRelation.destField
+                    },
+                    subquery: addPrimaryKeysToAst(
+                      this.#schema.tables[destSchema],
+                      sq._ast
+                    )
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        {
+          ...this.format,
+          relationships: {
+            ...this.format.relationships,
+            [relationship]: sq.format
+          }
+        },
+        this.customQueryID,
+        this.#currentJunction
+      );
+    }
+    throw new Error(`Invalid relationship ${relationship}`);
+  };
+  where = (fieldOrExpressionFactory, opOrValue, value) => {
+    let cond;
+    if (typeof fieldOrExpressionFactory === "function") {
+      cond = fieldOrExpressionFactory(
+        new ExpressionBuilder(this._exists)
+      );
+    } else {
+      assert(opOrValue !== void 0, "Invalid condition");
+      cond = cmp(fieldOrExpressionFactory, opOrValue, value);
+    }
+    const existingWhere = this._ast.where;
+    if (existingWhere) {
+      cond = and(existingWhere, cond);
+    }
+    const where = simplifyCondition(cond);
+    if (this.#system === "client") {
+      assertNoNotExists(where);
+    }
+    return this[newQuerySymbol](
+      this._delegate,
+      this.#schema,
+      this.#tableName,
+      {
+        ...this._ast,
+        where
+      },
+      this.format,
+      this.customQueryID,
+      this.#currentJunction
+    );
+  };
+  start = (row, opts) => this[newQuerySymbol](
+    this._delegate,
+    this.#schema,
+    this.#tableName,
+    {
+      ...this._ast,
+      start: {
+        row,
+        exclusive: !opts?.inclusive
+      }
+    },
+    this.format,
+    this.customQueryID,
+    this.#currentJunction
+  );
+  limit = (limit) => {
+    if (limit < 0) {
+      throw new Error("Limit must be non-negative");
+    }
+    if ((limit | 0) !== limit) {
+      throw new Error("Limit must be an integer");
+    }
+    if (this.#currentJunction) {
+      throw new NotImplementedError(
+        "Limit is not supported in junction relationships yet. Junction relationship being limited: " + this.#currentJunction
+      );
+    }
+    return this[newQuerySymbol](
+      this._delegate,
+      this.#schema,
+      this.#tableName,
+      {
+        ...this._ast,
+        limit
+      },
+      this.format,
+      this.customQueryID,
+      this.#currentJunction
+    );
+  };
+  orderBy = (field, direction) => {
+    if (this.#currentJunction) {
+      throw new NotImplementedError(
+        "Order by is not supported in junction relationships yet. Junction relationship being ordered: " + this.#currentJunction
+      );
+    }
+    return this[newQuerySymbol](
+      this._delegate,
+      this.#schema,
+      this.#tableName,
+      {
+        ...this._ast,
+        orderBy: [...this._ast.orderBy ?? [], [field, direction]]
+      },
+      this.format,
+      this.customQueryID,
+      this.#currentJunction
+    );
+  };
+  _exists = (relationship, cb, options) => {
+    cb = cb ?? ((q) => q);
+    const flip = options?.flip ?? false;
+    const related = this.#schema.relationships[this.#tableName][relationship];
+    assert(related, "Invalid relationship");
+    if (isOneHop(related)) {
+      const { destSchema, sourceField, destField } = related[0];
+      assert(isCompoundKey(sourceField), "Invalid relationship");
+      assert(isCompoundKey(destField), "Invalid relationship");
+      const sq = cb(
+        this[newQuerySymbol](
+          this._delegate,
+          this.#schema,
+          destSchema,
+          {
+            table: destSchema,
+            alias: `${SUBQ_PREFIX}${relationship}`
+          },
+          defaultFormat,
+          this.customQueryID,
+          void 0
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          system: this.#system,
+          correlation: {
+            parentField: sourceField,
+            childField: destField
+          },
+          subquery: addPrimaryKeysToAst(
+            this.#schema.tables[destSchema],
+            sq._ast
+          )
+        },
+        op: "EXISTS",
+        flip
+      };
+    }
+    if (isTwoHop(related)) {
+      const [firstRelation, secondRelation] = related;
+      assert(isCompoundKey(firstRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(firstRelation.destField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
+      const queryToDest = cb(
+        this[newQuerySymbol](
+          this._delegate,
+          this.#schema,
+          destSchema,
+          {
+            table: destSchema,
+            alias: `${SUBQ_PREFIX}zhidden_${relationship}`
+          },
+          defaultFormat,
+          this.customQueryID,
+          relationship
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          system: this.#system,
+          correlation: {
+            parentField: firstRelation.sourceField,
+            childField: firstRelation.destField
+          },
+          subquery: {
+            table: junctionSchema,
+            alias: `${SUBQ_PREFIX}${relationship}`,
+            orderBy: addPrimaryKeys(
+              this.#schema.tables[junctionSchema],
+              void 0
+            ),
+            where: {
+              type: "correlatedSubquery",
+              related: {
+                system: this.#system,
+                correlation: {
+                  parentField: secondRelation.sourceField,
+                  childField: secondRelation.destField
+                },
+                subquery: addPrimaryKeysToAst(
+                  this.#schema.tables[destSchema],
+                  queryToDest._ast
+                )
+              },
+              op: "EXISTS",
+              flip
+            }
+          }
+        },
+        op: "EXISTS",
+        flip
+      };
+    }
+    throw new Error(`Invalid relationship ${relationship}`);
+  };
+  #completedAST;
+  _completeAst() {
+    if (!this.#completedAST) {
+      const finalOrderBy = addPrimaryKeys(
+        this.#schema.tables[this.#tableName],
+        this._ast.orderBy
+      );
+      if (this._ast.start) {
+        const { row } = this._ast.start;
+        const narrowedRow = {};
+        for (const [field] of finalOrderBy) {
+          narrowedRow[field] = row[field];
+        }
+        this.#completedAST = {
+          ...this._ast,
+          start: {
+            ...this._ast.start,
+            row: narrowedRow
+          },
+          orderBy: finalOrderBy
+        };
+      } else {
+        this.#completedAST = {
+          ...this._ast,
+          orderBy: addPrimaryKeys(
+            this.#schema.tables[this.#tableName],
+            this._ast.orderBy
+          )
+        };
+      }
+    }
+    return this.#completedAST;
+  }
+};
+var completedAstSymbol = Symbol();
+var QueryImpl = class _QueryImpl extends AbstractQuery {
+  #system;
+  constructor(delegate, schema, tableName, ast = { table: tableName }, format = defaultFormat, system = "client", customQueryID, currentJunction) {
+    super(
+      delegate,
+      schema,
+      tableName,
+      ast,
+      format,
+      system,
+      customQueryID,
+      currentJunction
+    );
+    this.#system = system;
+  }
+  get [completedAstSymbol]() {
+    return this._completeAst();
+  }
+  [newQuerySymbol](delegate, schema, tableName, ast, format, customQueryID, currentJunction) {
+    return new _QueryImpl(
+      delegate,
+      schema,
+      tableName,
+      ast,
+      format,
+      this.#system,
+      customQueryID,
+      currentJunction
+    );
+  }
+  materialize(factoryOrTTL, ttl = DEFAULT_TTL_MS) {
+    const delegate = must(
+      this._delegate,
+      "materialize requires a query delegate to be set"
+    );
+    let factory;
+    if (typeof factoryOrTTL === "function") {
+      factory = factoryOrTTL;
+    } else {
+      ttl = factoryOrTTL ?? DEFAULT_TTL_MS;
+    }
+    const ast = this._completeAst();
+    const queryID = this.customQueryID ? hashOfNameAndArgs(this.customQueryID.name, this.customQueryID.args) : this.hash();
+    const queryCompleteResolver = resolver7();
+    let queryComplete = delegate.defaultQueryComplete;
+    const updateTTL = (newTTL) => {
+      this.customQueryID ? delegate.updateCustomQuery(this.customQueryID, newTTL) : delegate.updateServerQuery(ast, newTTL);
+    };
+    const gotCallback = (got, error) => {
+      if (error) {
+        queryCompleteResolver.reject(error);
+        queryComplete = error;
+        return;
+      }
+      if (got) {
+        delegate.addMetric(
+          "query-materialization-end-to-end",
+          performance.now() - t0,
+          queryID,
+          ast
+        );
+        queryComplete = true;
+        queryCompleteResolver.resolve(true);
+      }
+    };
+    let removeCommitObserver;
+    const onDestroy = () => {
+      input.destroy();
+      removeCommitObserver?.();
+      removeAddedQuery();
+    };
+    const t0 = performance.now();
+    const removeAddedQuery = this.customQueryID ? delegate.addCustomQuery(ast, this.customQueryID, ttl, gotCallback) : delegate.addServerQuery(ast, ttl, gotCallback);
+    const input = buildPipeline(ast, delegate, queryID);
+    const view = delegate.batchViewUpdates(
+      () => (factory ?? arrayViewFactory)(
+        this,
+        input,
+        this.format,
+        onDestroy,
+        (cb) => {
+          removeCommitObserver = delegate.onTransactionCommit(cb);
+        },
+        queryComplete || queryCompleteResolver.promise,
+        updateTTL
+      )
+    );
+    delegate.addMetric(
+      "query-materialization-client",
+      performance.now() - t0,
+      queryID
+    );
+    return view;
+  }
+  run(options) {
+    const delegate = must(
+      this._delegate,
+      "run requires a query delegate to be set"
+    );
+    delegate.assertValidRunOptions(options);
+    const v = this.materialize(options?.ttl);
+    if (options?.type === "complete") {
+      return new Promise((resolve) => {
+        v.addListener((data, type) => {
+          if (type === "complete") {
+            v.destroy();
+            resolve(data);
+          } else if (type === "error") {
+            v.destroy();
+            resolve(Promise.reject(data));
+          }
+        });
+      });
+    }
+    options?.type;
+    const ret = v.data;
+    v.destroy();
+    return Promise.resolve(ret);
+  }
+  preload(options) {
+    const delegate = must(
+      this._delegate,
+      "preload requires a query delegate to be set"
+    );
+    const ttl = options?.ttl ?? DEFAULT_PRELOAD_TTL_MS;
+    const ast = this._completeAst();
+    const { resolve, promise: complete } = resolver7();
+    if (this.customQueryID) {
+      const cleanup2 = delegate.addCustomQuery(
+        ast,
+        this.customQueryID,
+        ttl,
+        (got) => {
+          if (got) {
+            resolve();
+          }
+        }
+      );
+      return {
+        cleanup: cleanup2,
+        complete
+      };
+    }
+    const cleanup = delegate.addServerQuery(ast, ttl, (got) => {
+      if (got) {
+        resolve();
+      }
+    });
+    return {
+      cleanup,
+      complete
+    };
+  }
+};
+function addPrimaryKeys(schema, orderBy) {
+  orderBy = orderBy ?? [];
+  const { primaryKey } = schema;
+  const primaryKeysToAdd = new Set(primaryKey);
+  for (const [field] of orderBy) {
+    primaryKeysToAdd.delete(field);
+  }
+  if (primaryKeysToAdd.size === 0) {
+    return orderBy;
+  }
+  return [
+    ...orderBy,
+    ...[...primaryKeysToAdd].map((key) => [key, "asc"])
+  ];
+}
+function addPrimaryKeysToAst(schema, ast) {
+  return {
+    ...ast,
+    orderBy: addPrimaryKeys(schema, ast.orderBy)
+  };
+}
+function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete, updateTTL) {
+  const v = new ArrayView(
+    input,
+    format,
+    queryComplete,
+    updateTTL
+  );
+  v.onDestroy = onDestroy;
+  onTransactionCommit(() => {
+    v.flush();
+  });
+  return v;
+}
+function isCompoundKey(field) {
+  return Array.isArray(field) && field.length >= 1;
+}
+function isOneHop(r) {
+  return r.length === 1;
+}
+function isTwoHop(r) {
+  return r.length === 2;
+}
+
+// ../zero-client/src/util/socket.ts
+function send(ws, data) {
+  ws.send(JSON.stringify(data));
+}
+
+// ../zero-client/src/client/active-clients-manager.ts
+import { resolver as resolver8 } from "@rocicorp/resolver";
+var keyPrefix = "zero-active";
+function toLockName(clientGroupID, clientID) {
+  return `${keyPrefix}/${clientGroupID}/${clientID}`;
+}
+function toBroadcastChannelName(clientGroupID) {
+  return `${keyPrefix}/${clientGroupID}`;
+}
+function fromLockName(lockKey) {
+  if (!lockKey || !lockKey.startsWith(keyPrefix)) {
+    return void 0;
+  }
+  const parts = lockKey.slice(keyPrefix.length).split("/");
+  if (parts.length !== 3) {
+    return void 0;
+  }
+  return {
+    clientGroupID: parts[1],
+    clientID: parts[2]
+  };
+}
+function ignoreAbortError(e) {
+  if (e instanceof Error && e.name === "AbortError") {
+    return;
+  }
+  throw e;
+}
+var ActiveClientsManager = class _ActiveClientsManager {
+  clientGroupID;
+  clientID;
+  #resolver = resolver8();
+  #lockManager;
+  #activeClients = /* @__PURE__ */ new Set();
+  /**
+   * A callback that is called when a client is added to the client group.
+   * It receives the client ID of the added client.
+   */
+  onAdd;
+  /**
+   * A callback that is called when a client is deleted from the client group.
+   * It receives the client ID of the deleted client.
+   */
+  onDelete;
+  /**
+   * Creates an instance of `ActiveClientsManager` for the specified client
+   * group and client ID. It will return a promise that resolves when the
+   * instance is ready to use, which means that it has successfully acquired the
+   * exclusive lock for the client and has retrieved the list of active clients.
+   */
+  static async create(clientGroupID, clientID, signal) {
+    const instance = new _ActiveClientsManager(clientGroupID, clientID, signal);
+    await instance.#init(signal);
+    return instance;
+  }
+  constructor(clientGroupID, clientID, signal) {
+    this.clientGroupID = clientGroupID;
+    this.clientID = clientID;
+    this.#lockManager = getClientLockManager(signal);
+    this.#activeClients.add(clientID);
+  }
+  async #init(signal) {
+    const { clientGroupID, clientID } = this;
+    const name = toLockName(clientGroupID, clientID);
+    const channel = new bc(toBroadcastChannelName(clientGroupID));
+    channel.addEventListener(
       "message",
       (e) => {
         const client = fromLockName(e.data);
@@ -6732,7 +11082,7 @@ var Connecting = 1;
 var Connected = 2;
 
 // ../zql/src/ivm/memory-storage.ts
-import { compareUTF8 as compareUTF82 } from "compare-utf8";
+import { compareUTF8 as compareUTF83 } from "compare-utf8";
 
 // ../shared/src/btree-set.ts
 var MAX_NODE_SIZE = 32;
@@ -7000,8 +11350,8 @@ var BNode = class _BNode {
     return new _BNode(keys);
   }
   delete(key, tree) {
-    const cmp = tree.comparator;
-    const iLow = indexOf(key, this.keys, -1, cmp);
+    const cmp2 = tree.comparator;
+    const iLow = indexOf(key, this.keys, -1, cmp2);
     const iHigh = iLow + 1;
     if (iLow < 0) {
       return false;
@@ -7066,21 +11416,21 @@ var BNodeInternal = class _BNodeInternal extends BNode {
   }
   set(key, tree) {
     const c = this.children;
-    const cmp = tree.comparator;
-    let i = Math.min(indexOf(key, this.keys, 0, cmp), c.length - 1);
+    const cmp2 = tree.comparator;
+    let i = Math.min(indexOf(key, this.keys, 0, cmp2), c.length - 1);
     let child = c[i];
     if (child.isShared) {
       c[i] = child = child.clone();
     }
     if (child.keys.length >= MAX_NODE_SIZE) {
       let other;
-      if (i > 0 && (other = c[i - 1]).keys.length < MAX_NODE_SIZE && cmp(child.keys[0], key) < 0) {
+      if (i > 0 && (other = c[i - 1]).keys.length < MAX_NODE_SIZE && cmp2(child.keys[0], key) < 0) {
         if (other.isShared) {
           c[i - 1] = other = other.clone();
         }
         other.takeFromRight(child);
         this.keys[i - 1] = other.maxKey();
-      } else if ((other = c[i + 1]) !== void 0 && other.keys.length < MAX_NODE_SIZE && cmp(child.maxKey(), key) < 0) {
+      } else if ((other = c[i + 1]) !== void 0 && other.keys.length < MAX_NODE_SIZE && cmp2(child.maxKey(), key) < 0) {
         if (other.isShared) c[i + 1] = other = other.clone();
         other.takeFromLeft(child);
         this.keys[i] = c[i].maxKey();
@@ -7095,7 +11445,7 @@ var BNodeInternal = class _BNodeInternal extends BNode {
     }
     const newRightSibling = this.splitOffRightSide();
     let target = this;
-    if (cmp(result.maxKey(), this.maxKey()) > 0) {
+    if (cmp2(result.maxKey(), this.maxKey()) > 0) {
       target = newRightSibling;
       i -= this.keys.length;
     }
@@ -7131,10 +11481,10 @@ var BNodeInternal = class _BNodeInternal extends BNode {
     this.children.unshift(lhs.children.pop());
   }
   delete(key, tree) {
-    const cmp = tree.comparator;
+    const cmp2 = tree.comparator;
     const { keys } = this;
     const { children } = this;
-    let iLow = indexOf(key, this.keys, 0, cmp);
+    let iLow = indexOf(key, this.keys, 0, cmp2);
     let i = iLow;
     const iHigh = Math.min(iLow, keys.length - 1);
     if (i <= iHigh) {
@@ -7223,7 +11573,7 @@ emptyLeaf.isShared = true;
 
 // ../zql/src/ivm/memory-storage.ts
 function comparator(a, b) {
-  return compareUTF82(a[0], b[0]);
+  return compareUTF83(a[0], b[0]);
 }
 var MemoryStorage = class {
   #data = new BTreeSet(comparator);
@@ -7451,7 +11801,7 @@ var MemorySource = class _MemorySource {
       scanStart = startAt;
     }
     const rowsIterable = generateRows(data, scanStart, req.reverse);
-    const withOverlay = generateWithOverlay(
+    const withOverlay = generateWithOverlay2(
       startAt,
       pkConstraint ? once(rowsIterable) : rowsIterable,
       // use `req.constraint` here and not `fetchOrPkConstraint` since `fetchOrPkConstraint` could be the
@@ -7673,7 +12023,7 @@ function* generateWithStart(nodes, start, compare2) {
     }
   }
 }
-function* generateWithOverlay(startAt, rows, constraint, overlay, connectionIndex, compare2, filterPredicate) {
+function* generateWithOverlay2(startAt, rows, constraint, overlay, connectionIndex, compare2, filterPredicate) {
   let overlayToApply = void 0;
   if (overlay && connectionIndex <= overlay.outputIndex) {
     overlayToApply = overlay;
@@ -7723,24 +12073,24 @@ function computeOverlays(startAt, constraint, overlay, compare2, filterPredicate
   }
   return overlays;
 }
-function overlaysForStartAt({ add, remove }, startAt, compare2) {
+function overlaysForStartAt({ add: add2, remove }, startAt, compare2) {
   const undefinedIfBeforeStartAt = (row) => row === void 0 || compare2(row, startAt) < 0 ? void 0 : row;
   return {
-    add: undefinedIfBeforeStartAt(add),
+    add: undefinedIfBeforeStartAt(add2),
     remove: undefinedIfBeforeStartAt(remove)
   };
 }
-function overlaysForConstraint({ add, remove }, constraint) {
+function overlaysForConstraint({ add: add2, remove }, constraint) {
   const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !constraintMatchesRow(constraint, row) ? void 0 : row;
   return {
-    add: undefinedIfDoesntMatchConstraint(add),
+    add: undefinedIfDoesntMatchConstraint(add2),
     remove: undefinedIfDoesntMatchConstraint(remove)
   };
 }
-function overlaysForFilterPredicate({ add, remove }, filterPredicate) {
+function overlaysForFilterPredicate({ add: add2, remove }, filterPredicate) {
   const undefinedIfDoesntMatchFilter = (row) => row === void 0 || !filterPredicate(row) ? void 0 : row;
   return {
-    add: undefinedIfDoesntMatchFilter(add),
+    add: undefinedIfDoesntMatchFilter(add2),
     remove: undefinedIfDoesntMatchFilter(remove)
   };
 }
@@ -7749,15 +12099,15 @@ function* generateWithOverlayInner(rowIterator, overlays, compare2) {
   let removeOverlaySkipped = false;
   for (const row of rowIterator) {
     if (!addOverlayYielded && overlays.add) {
-      const cmp = compare2(overlays.add, row);
-      if (cmp < 0) {
+      const cmp2 = compare2(overlays.add, row);
+      if (cmp2 < 0) {
         addOverlayYielded = true;
         yield { row: overlays.add, relationships: {} };
       }
     }
     if (!removeOverlaySkipped && overlays.remove) {
-      const cmp = compare2(overlays.remove, row);
-      if (cmp === 0) {
+      const cmp2 = compare2(overlays.remove, row);
+      if (cmp2 === 0) {
         removeOverlaySkipped = true;
         continue;
       }
@@ -7774,9 +12124,9 @@ function makeBoundComparator(sort) {
   return (a, b) => {
     for (const entry of sort) {
       const key = entry[0];
-      const cmp = compareBounds(a[key], b[key]);
-      if (cmp !== 0) {
-        return entry[1] === "asc" ? cmp : -cmp;
+      const cmp2 = compareBounds(a[key], b[key]);
+      if (cmp2 !== 0) {
+        return entry[1] === "asc" ? cmp2 : -cmp2;
       }
     }
     return 0;
@@ -8692,7 +13042,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.24.2025100900";
+var version2 = "0.24.2025101200";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -8987,7 +13337,7 @@ var State = class {
 };
 
 // ../zero-client/src/client/mutation-tracker.ts
-import { resolver as resolver8 } from "@rocicorp/resolver";
+import { resolver as resolver9 } from "@rocicorp/resolver";
 var currentEphemeralID = 0;
 function nextEphemeralID() {
   return ++currentEphemeralID;
@@ -9025,7 +13375,7 @@ var MutationTracker = class {
   }
   trackMutation() {
     const id = nextEphemeralID();
-    const mutationResolver = resolver8();
+    const mutationResolver = resolver9();
     this.#outstandingMutations.set(id, {
       resolver: mutationResolver
     });
@@ -10229,12 +14579,12 @@ var Zero = class _Zero {
   };
   #zeroContext;
   queryDelegate;
-  #connectResolver = resolver9();
+  #connectResolver = resolver10();
   #pendingPullsByRequestID = /* @__PURE__ */ new Map();
   #lastMutationIDReceived = 0;
   #socket = void 0;
-  #socketResolver = resolver9();
-  #connectionStateChangeResolver = resolver9();
+  #socketResolver = resolver10();
+  #connectionStateChangeResolver = resolver10();
   /**
    * This resolver is only used for rejections. It is awaited in the connected
    * state (including when waiting for a pong). It is rejected when we get an
@@ -10253,7 +14603,7 @@ var Zero = class _Zero {
     }
     this.#connectionState = state;
     this.#connectionStateChangeResolver.resolve(state);
-    this.#connectionStateChangeResolver = resolver9();
+    this.#connectionStateChangeResolver = resolver10();
     if (false) {
       asTestZero(this)[onSetConnectionStateSymbol]?.(state);
     }
@@ -11081,9 +15431,9 @@ ${error.errorBody.message}`, error);
         lc.error?.("disconnect() called while disconnected");
         break;
     }
-    this.#socketResolver = resolver9();
+    this.#socketResolver = resolver10();
     lc.debug?.("Creating new connect resolver");
-    this.#connectResolver = resolver9();
+    this.#connectResolver = resolver10();
     this.#setConnectionState(Disconnected);
     this.#messageCount = 0;
     this.#connectStart = void 0;
@@ -11130,12 +15480,12 @@ ${error.errorBody.message}`, error);
     const body = pullResponseMessage[1];
     lc = lc.withContext("requestID", body.requestID);
     lc.debug?.("Handling pull response", body);
-    const resolver10 = this.#pendingPullsByRequestID.get(body.requestID);
-    if (!resolver10) {
+    const resolver11 = this.#pendingPullsByRequestID.get(body.requestID);
+    if (!resolver11) {
       lc.debug?.("No resolver found");
       return;
     }
-    resolver10.resolve(pullResponseMessage[1]);
+    resolver11.resolve(pullResponseMessage[1]);
   }
   async #pusher(req, requestID) {
     assert(req.pushVersion === 1);
@@ -11268,7 +15618,7 @@ ${error.errorBody.message}`, error);
               PING_INTERVAL_MS,
               controller.signal
             );
-            this.#rejectMessageError = resolver9();
+            this.#rejectMessageError = resolver10();
             const PING = 0;
             const HIDDEN = 2;
             const raceResult = await promiseRace([
@@ -11383,7 +15733,7 @@ ${error.errorBody.message}`, error);
       }
     ];
     send(socket, pullRequestMessage);
-    const pullResponseResolver = resolver9();
+    const pullResponseResolver = resolver10();
     this.#pendingPullsByRequestID.set(requestID, pullResponseResolver);
     try {
       const TIMEOUT = 0;
@@ -11446,7 +15796,7 @@ ${error.errorBody.message}`, error);
    */
   async #ping(lc, messageErrorRejectionPromise) {
     lc.debug?.("pinging");
-    const { promise, resolve } = resolver9();
+    const { promise, resolve } = resolver10();
     this.#onPong = resolve;
     const pingMessage = ["ping", {}];
     const t0 = performance.now();
@@ -11664,8 +16014,15 @@ export {
   json,
   enumeration,
   createSchema,
+  defaultFormat,
+  ExpressionBuilder,
+  idSymbol,
+  applyChange,
+  newQuery,
+  newQuerySymbol,
+  AbstractQuery,
   clientToServer,
   update_needed_reason_type_enum_exports,
   Zero
 };
-//# sourceMappingURL=chunk-2MVN6X6T.js.map
+//# sourceMappingURL=chunk-5J6ROZSO.js.map