@rocicorp/zero 0.24.2025091100 → 0.24.2025092400

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

@@ -144,7 +144,7 @@ function getDeepestUnionParseError(value, schema, mode) {
   try {
     const str = JSON.stringify(value);
     return `Invalid union value: ${str}`;
-  } catch (e) {
+  } catch {
     return `Invalid union value`;
   }
 }
@@ -236,100 +236,144 @@ function literalUnion(...literals) {
   return v.union(...literals.map(v.literal));
 }
 
-// ../replicache/src/dag/store.ts
-var ChunkNotFoundError = class extends Error {
-  name = "ChunkNotFoundError";
-  hash;
-  constructor(hash2) {
-    super(`Chunk not found ${hash2}`);
-    this.hash = hash2;
+// ../shared/src/json.ts
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
   }
-};
-async function mustGetChunk(store, hash2) {
-  const chunk = await store.getChunk(hash2);
-  if (chunk) {
-    return chunk;
+  if (typeof a !== typeof b) {
+    return false;
   }
-  throw new ChunkNotFoundError(hash2);
+  switch (typeof a) {
+    case "boolean":
+    case "number":
+    case "string":
+      return false;
+  }
+  a = a;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false;
+    }
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a === null || b === null) {
+    return false;
+  }
+  if (Array.isArray(b)) {
+    return false;
+  }
+  a = a;
+  b = b;
+  let aSize = 0;
+  for (const key in a) {
+    if (hasOwn(a, key)) {
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+      aSize++;
+    }
+  }
+  let bSize = 0;
+  for (const key in b) {
+    if (hasOwn(b, key)) {
+      bSize++;
+    }
+  }
+  return aSize === bSize;
 }
-async function mustGetHeadHash(name, store) {
-  const hash2 = await store.getHead(name);
-  assert(hash2, `Missing head ${name}`);
-  return hash2;
+function assertJSONValue(v2) {
+  if (isProd) {
+    return;
+  }
+  switch (typeof v2) {
+    case "boolean":
+    case "number":
+    case "string":
+      return;
+    case "object":
+      if (v2 === null) {
+        return;
+      }
+      if (Array.isArray(v2)) {
+        return assertJSONArray(v2);
+      }
+      return assertObjectIsJSONObject(v2);
+  }
+  throwInvalidType(v2, "JSON value");
 }
-
-// ../replicache/src/with-transactions.ts
-function withRead(store, fn) {
-  return using(store.read(), fn);
+function assertJSONObject(v2) {
+  assertObject(v2);
+  assertObjectIsJSONObject(v2);
 }
-function withWriteNoImplicitCommit(store, fn) {
-  return using(store.write(), fn);
+function assertObjectIsJSONObject(v2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      const value = v2[k];
+      if (value !== void 0) {
+        assertJSONValue(value);
+      }
+    }
+  }
 }
-function withWrite(store, fn) {
-  return using(store.write(), async (write) => {
-    const result = await fn(write);
-    await write.commit();
-    return result;
-  });
+function assertJSONArray(v2) {
+  for (const item of v2) {
+    assertJSONValue(item);
+  }
 }
-async function using(x, fn) {
-  const write = await x;
-  try {
-    return await fn(write);
-  } finally {
-    write.release();
+function isJSONValue(v2, path2) {
+  switch (typeof v2) {
+    case "boolean":
+    case "number":
+    case "string":
+      return true;
+    case "object":
+      if (v2 === null) {
+        return true;
+      }
+      if (Array.isArray(v2)) {
+        return isJSONArray(v2, path2);
+      }
+      return objectIsJSONObject(v2, path2);
   }
+  return false;
 }
-
-// ../replicache/src/dag/chunk.ts
-function asRefs(sortedRefs) {
-  return sortedRefs;
+function isJSONObject(v2, path2) {
+  if (typeof v2 !== "object" || v2 === null) {
+    return false;
+  }
+  return objectIsJSONObject(v2, path2);
 }
-function toRefs(refs) {
-  if (Array.isArray(refs)) {
-    refs.sort();
-    for (let i = 1; i < refs.length; i++) {
-      assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
+function objectIsJSONObject(v2, path2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      path2.push(k);
+      const value = v2[k];
+      if (value !== void 0 && !isJSONValue(value, path2)) {
+        return false;
+      }
+      path2.pop();
     }
-    return asRefs(refs);
   }
-  const refsArray = [...refs];
-  refsArray.sort();
-  return asRefs(refsArray);
+  return true;
 }
-var Chunk = class {
-  hash;
-  data;
-  /**
-   * Meta is an array of refs. If there are no refs we do not write a meta
-   * chunk.
-   */
-  meta;
-  constructor(hash2, data, refs) {
-    assert(
-      !refs.includes(hash2),
-      "Chunk cannot reference itself"
-    );
-    assertDeepFrozen(data);
-    this.hash = hash2;
-    this.data = data;
-    this.meta = refs;
-  }
-};
-function assertRefs(v2) {
-  if (!Array.isArray(v2)) {
-    throw new Error("Refs must be an array");
-  }
-  if (v2.length > 0) {
-    assertString(v2[0]);
-    for (let i = 1; i < v2.length; i++) {
-      assertString(v2[i]);
+function isJSONArray(v2, path2) {
+  for (let i = 0; i < v2.length; i++) {
+    path2.push(i);
+    if (!isJSONValue(v2[i], path2)) {
+      return false;
     }
+    path2.pop();
   }
-}
-function createChunk(data, refs, chunkHasher) {
-  const hash2 = chunkHasher();
-  return new Chunk(hash2, data, refs);
+  return true;
 }
 
 // ../shared/src/random-uint64.ts
@@ -367,339 +411,6 @@ function assertHash(value) {
 }
 var hashSchema = valita_exports.string().assert(isHash, "Invalid hash");
 
-// ../replicache/src/index-defs.ts
-var indexDefinitionSchema = readonlyObject({
-  prefix: valita_exports.string().optional(),
-  jsonPointer: valita_exports.string(),
-  allowEmpty: valita_exports.boolean().optional()
-});
-var indexDefinitionsSchema = readonlyRecord(
-  indexDefinitionSchema
-);
-function indexDefinitionEqual(a, b) {
-  return a.jsonPointer === b.jsonPointer && (a.allowEmpty ?? false) === (b.allowEmpty ?? false) && (a.prefix ?? "") === (b.prefix ?? "");
-}
-function indexDefinitionsEqual(a, b) {
-  if (Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const [aKey, aValue] of Object.entries(a)) {
-    const bValue = b[aKey];
-    if (!bValue || !indexDefinitionEqual(aValue, bValue)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// ../replicache/src/persist/client-groups.ts
-var clientGroupSchema = readonlyObject({
-  /**
-   * The hash of the commit in the perdag last persisted to this client group.
-   * Should only be updated by clients assigned to this client group.
-   */
-  headHash: hashSchema,
-  /**
-   * Set of mutator names common to all clients assigned to this client group.
-   */
-  mutatorNames: readonlyArray(valita_exports.string()),
-  /**
-   * Index definitions common to all clients assigned to this client group.
-   */
-  indexes: indexDefinitionsSchema,
-  /**
-   * The highest mutation ID of every client assigned to this client group.
-   * Should only be updated by clients assigned to this client group. Read by
-   * other clients to determine if there are unacknowledged pending mutations
-   * for them to try to recover. This is redundant with information in the
-   * commit graph at `headHash`, but allows other clients to determine if there
-   * are unacknowledged pending mutations without having to load the commit
-   * graph.
-   */
-  mutationIDs: readonlyRecord(valita_exports.number()),
-  /**
-   * The highest lastMutationID received from the server for every client
-   * assigned to this client group.
-   *
-   * Should be updated by the clients assigned to this client group whenever
-   * they persist to this client group. Read by other clients to determine if
-   * there are unacknowledged pending mutations for them to recover and
-   * *updated* by other clients upon successfully recovering pending mutations
-   * to avoid redundant pushes of pending mutations.
-   *
-   * Note: This will be the same as the `lastMutationIDs` of the base snapshot
-   * of the client group's commit graph when written by clients assigned to this
-   * client group.  However, when written by another client recovering mutations
-   * it may be different because the other client does not update the commit
-   * graph.
-   */
-  lastServerAckdMutationIDs: valita_exports.record(valita_exports.number()),
-  /**
-   * If the server deletes this client group it can signal that the client group
-   * was deleted. If that happens we mark this client group as disabled so that
-   * we do not use it again when creating new clients.
-   */
-  disabled: valita_exports.boolean()
-});
-var CLIENT_GROUPS_HEAD_NAME = "client-groups";
-function assertClientGroup(value) {
-  assert2(value, clientGroupSchema);
-}
-function chunkDataToClientGroupMap(chunkData) {
-  assertObject(chunkData);
-  const clientGroups = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(chunkData)) {
-    if (value !== void 0) {
-      assertClientGroup(value);
-      clientGroups.set(key, value);
-    }
-  }
-  return clientGroups;
-}
-function clientGroupMapToChunkData(clientGroups, dagWrite) {
-  const chunkData = {};
-  for (const [clientGroupID, clientGroup] of clientGroups.entries()) {
-    dagWrite.assertValidHash(clientGroup.headHash);
-    chunkData[clientGroupID] = {
-      ...clientGroup,
-      mutatorNames: [...clientGroup.mutatorNames.values()]
-    };
-  }
-  return deepFreeze(chunkData);
-}
-async function getClientGroupsAtHash(hash2, dagRead) {
-  const chunk = await dagRead.getChunk(hash2);
-  return chunkDataToClientGroupMap(chunk?.data);
-}
-async function getClientGroups(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
-  if (!hash2) {
-    return /* @__PURE__ */ new Map();
-  }
-  return getClientGroupsAtHash(hash2, dagRead);
-}
-async function setClientGroups(clientGroups, dagWrite) {
-  const currClientGroups = await getClientGroups(dagWrite);
-  for (const [clientGroupID, clientGroup] of clientGroups) {
-    const currClientGroup = currClientGroups.get(clientGroupID);
-    validateClientGroupUpdate(clientGroup, currClientGroup);
-  }
-  return setValidatedClientGroups(clientGroups, dagWrite);
-}
-async function setClientGroup(clientGroupID, clientGroup, dagWrite) {
-  const currClientGroups = await getClientGroups(dagWrite);
-  const currClientGroup = currClientGroups.get(clientGroupID);
-  validateClientGroupUpdate(clientGroup, currClientGroup);
-  const newClientGroups = new Map(currClientGroups);
-  newClientGroups.set(clientGroupID, clientGroup);
-  return setValidatedClientGroups(newClientGroups, dagWrite);
-}
-function validateClientGroupUpdate(clientGroup, currClientGroup) {
-  const mutatorNamesSet = new Set(clientGroup.mutatorNames);
-  assert(
-    mutatorNamesSet.size === clientGroup.mutatorNames.length,
-    "A client group's mutatorNames must be a set."
-  );
-  if (currClientGroup !== void 0) {
-    assert(
-      indexDefinitionsEqual(currClientGroup.indexes, clientGroup.indexes),
-      "A client group's index definitions must never change."
-    );
-    assert(
-      mutatorNamesEqual(mutatorNamesSet, currClientGroup.mutatorNames),
-      "A client group's mutatorNames must never change."
-    );
-  }
-}
-async function setValidatedClientGroups(clientGroups, dagWrite) {
-  const chunkData = clientGroupMapToChunkData(clientGroups, dagWrite);
-  const refs = /* @__PURE__ */ new Set();
-  for (const clientGroup of clientGroups.values()) {
-    refs.add(clientGroup.headHash);
-  }
-  const chunk = dagWrite.createChunk(chunkData, toRefs(refs));
-  await dagWrite.putChunk(chunk);
-  await dagWrite.setHead(CLIENT_GROUPS_HEAD_NAME, chunk.hash);
-  return clientGroups;
-}
-function mutatorNamesEqual(mutatorNamesSet, mutatorNames) {
-  if (mutatorNames.length !== mutatorNamesSet.size) {
-    return false;
-  }
-  for (const mutatorName of mutatorNames) {
-    if (!mutatorNamesSet.has(mutatorName)) {
-      return false;
-    }
-  }
-  return true;
-}
-async function getClientGroup(id, dagRead) {
-  const clientGroups = await getClientGroups(dagRead);
-  return clientGroups.get(id);
-}
-function clientGroupHasPendingMutations(clientGroup) {
-  for (const [clientID, mutationID] of Object.entries(
-    clientGroup.mutationIDs
-  )) {
-    const lastServerAckdMutationID = clientGroup.lastServerAckdMutationIDs[clientID];
-    if (lastServerAckdMutationID === void 0 && mutationID !== 0 || lastServerAckdMutationID < mutationID) {
-      return true;
-    }
-  }
-  return false;
-}
-async function disableClientGroup(clientGroupID, dagWrite) {
-  const clientGroup = await getClientGroup(clientGroupID, dagWrite);
-  if (!clientGroup) {
-    return;
-  }
-  const disabledClientGroup = {
-    ...clientGroup,
-    disabled: true
-  };
-  await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
-}
-
-// ../shared/src/json.ts
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== typeof b) {
-    return false;
-  }
-  switch (typeof a) {
-    case "boolean":
-    case "number":
-    case "string":
-      return false;
-  }
-  a = a;
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) {
-      return false;
-    }
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (a === null || b === null) {
-    return false;
-  }
-  if (Array.isArray(b)) {
-    return false;
-  }
-  a = a;
-  b = b;
-  let aSize = 0;
-  for (const key in a) {
-    if (hasOwn(a, key)) {
-      if (!deepEqual(a[key], b[key])) {
-        return false;
-      }
-      aSize++;
-    }
-  }
-  let bSize = 0;
-  for (const key in b) {
-    if (hasOwn(b, key)) {
-      bSize++;
-    }
-  }
-  return aSize === bSize;
-}
-function assertJSONValue(v2) {
-  if (isProd) {
-    return;
-  }
-  switch (typeof v2) {
-    case "boolean":
-    case "number":
-    case "string":
-      return;
-    case "object":
-      if (v2 === null) {
-        return;
-      }
-      if (Array.isArray(v2)) {
-        return assertJSONArray(v2);
-      }
-      return assertObjectIsJSONObject(v2);
-  }
-  throwInvalidType(v2, "JSON value");
-}
-function assertJSONObject(v2) {
-  assertObject(v2);
-  assertObjectIsJSONObject(v2);
-}
-function assertObjectIsJSONObject(v2) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
-      const value = v2[k];
-      if (value !== void 0) {
-        assertJSONValue(value);
-      }
-    }
-  }
-}
-function assertJSONArray(v2) {
-  for (const item of v2) {
-    assertJSONValue(item);
-  }
-}
-function isJSONValue(v2, path2) {
-  switch (typeof v2) {
-    case "boolean":
-    case "number":
-    case "string":
-      return true;
-    case "object":
-      if (v2 === null) {
-        return true;
-      }
-      if (Array.isArray(v2)) {
-        return isJSONArray(v2, path2);
-      }
-      return objectIsJSONObject(v2, path2);
-  }
-  return false;
-}
-function isJSONObject(v2, path2) {
-  if (typeof v2 !== "object" || v2 === null) {
-    return false;
-  }
-  return objectIsJSONObject(v2, path2);
-}
-function objectIsJSONObject(v2, path2) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
-      path2.push(k);
-      const value = v2[k];
-      if (value !== void 0 && !isJSONValue(value, path2)) {
-        return false;
-      }
-      path2.pop();
-    }
-  }
-  return true;
-}
-function isJSONArray(v2, path2) {
-  for (let i = 0; i < v2.length; i++) {
-    path2.push(i);
-    if (!isJSONValue(v2[i], path2)) {
-      return false;
-    }
-    path2.pop();
-  }
-  return true;
-}
-
 // ../replicache/src/size-of-value.ts
 var SIZE_TAG = 1;
 var SIZE_INT32 = 4;
@@ -965,13 +676,13 @@ var DataNodeImpl = class extends NodeImpl {
     }
   }
 };
-function readonlySplice(array6, start, deleteCount, ...items) {
-  const arr = array6.slice(0, start);
+function readonlySplice(array7, start, deleteCount, ...items) {
+  const arr = array7.slice(0, start);
   for (let i = 0; i < items.length; i++) {
     arr.push(items[i]);
   }
-  for (let i = start + deleteCount; i < array6.length; i++) {
-    arr.push(array6[i]);
+  for (let i = start + deleteCount; i < array7.length; i++) {
+    arr.push(array7[i]);
   }
   return arr;
 }
@@ -1551,28 +1262,101 @@ function compareCookies(a, b) {
   if (b === null) {
     return 1;
   }
-  const cva = getCompareValue(a);
-  const cvb = getCompareValue(b);
-  if (typeof cva === "string" || typeof cvb === "string") {
-    return stringCompare(String(cva), String(cvb));
+  const cva = getCompareValue(a);
+  const cvb = getCompareValue(b);
+  if (typeof cva === "string" || typeof cvb === "string") {
+    return stringCompare(String(cva), String(cvb));
+  }
+  return cva - cvb;
+}
+function getCompareValue(cookie) {
+  if (typeof cookie === "string" || typeof cookie === "number") {
+    return cookie;
+  }
+  return cookie.order;
+}
+function assertCookie(v2) {
+  if (v2 === null || typeof v2 === "string" || typeof v2 === "number") {
+    return;
+  }
+  assertJSONObject(v2);
+  if (typeof v2.order === "string" || typeof v2.order === "number") {
+    return;
+  }
+  throw new Error("Invalid cookie");
+}
+
+// ../replicache/src/dag/chunk.ts
+function asRefs(sortedRefs) {
+  return sortedRefs;
+}
+function toRefs(refs) {
+  if (Array.isArray(refs)) {
+    refs.sort();
+    for (let i = 1; i < refs.length; i++) {
+      assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
+    }
+    return asRefs(refs);
+  }
+  const refsArray = [...refs];
+  refsArray.sort();
+  return asRefs(refsArray);
+}
+var Chunk = class {
+  hash;
+  data;
+  /**
+   * Meta is an array of refs. If there are no refs we do not write a meta
+   * chunk.
+   */
+  meta;
+  constructor(hash2, data, refs) {
+    assert(
+      !refs.includes(hash2),
+      "Chunk cannot reference itself"
+    );
+    assertDeepFrozen(data);
+    this.hash = hash2;
+    this.data = data;
+    this.meta = refs;
+  }
+};
+function assertRefs(v2) {
+  if (!Array.isArray(v2)) {
+    throw new Error("Refs must be an array");
+  }
+  if (v2.length > 0) {
+    assertString(v2[0]);
+    for (let i = 1; i < v2.length; i++) {
+      assertString(v2[i]);
+    }
   }
-  return cva - cvb;
 }
-function getCompareValue(cookie) {
-  if (typeof cookie === "string" || typeof cookie === "number") {
-    return cookie;
-  }
-  return cookie.order;
+function createChunk(data, refs, chunkHasher) {
+  const hash2 = chunkHasher();
+  return new Chunk(hash2, data, refs);
 }
-function assertCookie(v2) {
-  if (v2 === null || typeof v2 === "string" || typeof v2 === "number") {
-    return;
+
+// ../replicache/src/dag/store.ts
+var ChunkNotFoundError = class extends Error {
+  name = "ChunkNotFoundError";
+  hash;
+  constructor(hash2) {
+    super(`Chunk not found ${hash2}`);
+    this.hash = hash2;
   }
-  assertJSONObject(v2);
-  if (typeof v2.order === "string" || typeof v2.order === "number") {
-    return;
+};
+async function mustGetChunk(store, hash2) {
+  const chunk = await store.getChunk(hash2);
+  if (chunk) {
+    return chunk;
   }
-  throw new Error("Invalid cookie");
+  throw new ChunkNotFoundError(hash2);
+}
+async function mustGetHeadHash(name, store) {
+  const hash2 = await store.getHead(name);
+  assert(hash2, `Missing head ${name}`);
+  return hash2;
 }
 
 // ../replicache/src/db/meta-type-enum.ts
@@ -2035,54 +1819,270 @@ var Read = class {
   has(key) {
     return this.map.has(key);
   }
-  get(key) {
-    return this.map.get(key);
+  get(key) {
+    return this.map.get(key);
+  }
+  isEmpty() {
+    return this.map.isEmpty();
+  }
+  getMapForIndex(indexName) {
+    const idx = this.indexes.get(indexName);
+    if (idx === void 0) {
+      throw new Error(`Unknown index name: ${indexName}`);
+    }
+    return idx.map;
+  }
+  get closed() {
+    return this.#dagRead.closed;
+  }
+  close() {
+    this.#dagRead.release();
+  }
+};
+function readFromDefaultHead(dagRead, formatVersion) {
+  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);
+}
+async function readFromHead(name, dagRead, formatVersion) {
+  const commit = await commitFromHead(name, dagRead);
+  return readFromCommit(commit, dagRead, formatVersion);
+}
+async function readFromHash(hash2, dagRead, formatVersion) {
+  const commit = await commitFromHash(hash2, dagRead);
+  return readFromCommit(commit, dagRead, formatVersion);
+}
+function readFromCommit(commit, dagRead, formatVersion) {
+  const indexes = readIndexesForRead(commit, dagRead, formatVersion);
+  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);
+  return new Read(dagRead, map, indexes);
+}
+function readIndexesForRead(commit, dagRead, formatVersion) {
+  const m = /* @__PURE__ */ new Map();
+  for (const index of commit.indexes) {
+    m.set(
+      index.definition.name,
+      new IndexRead(
+        index,
+        new BTreeRead(dagRead, formatVersion, index.valueHash)
+      )
+    );
+  }
+  return m;
+}
+
+// ../replicache/src/with-transactions.ts
+function withRead(store, fn) {
+  return using(store.read(), fn);
+}
+function withWriteNoImplicitCommit(store, fn) {
+  return using(store.write(), fn);
+}
+function withWrite(store, fn) {
+  return using(store.write(), async (write) => {
+    const result = await fn(write);
+    await write.commit();
+    return result;
+  });
+}
+async function using(x, fn) {
+  const write = await x;
+  try {
+    return await fn(write);
+  } finally {
+    write.release();
+  }
+}
+
+// ../replicache/src/index-defs.ts
+var indexDefinitionSchema = readonlyObject({
+  prefix: valita_exports.string().optional(),
+  jsonPointer: valita_exports.string(),
+  allowEmpty: valita_exports.boolean().optional()
+});
+var indexDefinitionsSchema = readonlyRecord(
+  indexDefinitionSchema
+);
+function indexDefinitionEqual(a, b) {
+  return a.jsonPointer === b.jsonPointer && (a.allowEmpty ?? false) === (b.allowEmpty ?? false) && (a.prefix ?? "") === (b.prefix ?? "");
+}
+function indexDefinitionsEqual(a, b) {
+  if (Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const [aKey, aValue] of Object.entries(a)) {
+    const bValue = b[aKey];
+    if (!bValue || !indexDefinitionEqual(aValue, bValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../replicache/src/persist/client-groups.ts
+var clientGroupSchema = readonlyObject({
+  /**
+   * The hash of the commit in the perdag last persisted to this client group.
+   * Should only be updated by clients assigned to this client group.
+   */
+  headHash: hashSchema,
+  /**
+   * Set of mutator names common to all clients assigned to this client group.
+   */
+  mutatorNames: readonlyArray(valita_exports.string()),
+  /**
+   * Index definitions common to all clients assigned to this client group.
+   */
+  indexes: indexDefinitionsSchema,
+  /**
+   * The highest mutation ID of every client assigned to this client group.
+   * Should only be updated by clients assigned to this client group. Read by
+   * other clients to determine if there are unacknowledged pending mutations
+   * for them to try to recover. This is redundant with information in the
+   * commit graph at `headHash`, but allows other clients to determine if there
+   * are unacknowledged pending mutations without having to load the commit
+   * graph.
+   */
+  mutationIDs: readonlyRecord(valita_exports.number()),
+  /**
+   * The highest lastMutationID received from the server for every client
+   * assigned to this client group.
+   *
+   * Should be updated by the clients assigned to this client group whenever
+   * they persist to this client group. Read by other clients to determine if
+   * there are unacknowledged pending mutations for them to recover and
+   * *updated* by other clients upon successfully recovering pending mutations
+   * to avoid redundant pushes of pending mutations.
+   *
+   * Note: This will be the same as the `lastMutationIDs` of the base snapshot
+   * of the client group's commit graph when written by clients assigned to this
+   * client group.  However, when written by another client recovering mutations
+   * it may be different because the other client does not update the commit
+   * graph.
+   */
+  lastServerAckdMutationIDs: valita_exports.record(valita_exports.number()),
+  /**
+   * If the server deletes this client group it can signal that the client group
+   * was deleted. If that happens we mark this client group as disabled so that
+   * we do not use it again when creating new clients.
+   */
+  disabled: valita_exports.boolean()
+});
+var CLIENT_GROUPS_HEAD_NAME = "client-groups";
+function assertClientGroup(value) {
+  assert2(value, clientGroupSchema);
+}
+function chunkDataToClientGroupMap(chunkData) {
+  assertObject(chunkData);
+  const clientGroups = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(chunkData)) {
+    if (value !== void 0) {
+      assertClientGroup(value);
+      clientGroups.set(key, value);
+    }
+  }
+  return clientGroups;
+}
+function clientGroupMapToChunkData(clientGroups, dagWrite) {
+  const chunkData = {};
+  for (const [clientGroupID, clientGroup] of clientGroups.entries()) {
+    dagWrite.assertValidHash(clientGroup.headHash);
+    chunkData[clientGroupID] = {
+      ...clientGroup,
+      mutatorNames: [...clientGroup.mutatorNames.values()]
+    };
+  }
+  return deepFreeze(chunkData);
+}
+async function getClientGroupsAtHash(hash2, dagRead) {
+  const chunk = await dagRead.getChunk(hash2);
+  return chunkDataToClientGroupMap(chunk?.data);
+}
+async function getClientGroups(dagRead) {
+  const hash2 = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
+  if (!hash2) {
+    return /* @__PURE__ */ new Map();
+  }
+  return getClientGroupsAtHash(hash2, dagRead);
+}
+async function setClientGroups(clientGroups, dagWrite) {
+  const currClientGroups = await getClientGroups(dagWrite);
+  for (const [clientGroupID, clientGroup] of clientGroups) {
+    const currClientGroup = currClientGroups.get(clientGroupID);
+    validateClientGroupUpdate(clientGroup, currClientGroup);
+  }
+  return setValidatedClientGroups(clientGroups, dagWrite);
+}
+async function setClientGroup(clientGroupID, clientGroup, dagWrite) {
+  const currClientGroups = await getClientGroups(dagWrite);
+  const currClientGroup = currClientGroups.get(clientGroupID);
+  validateClientGroupUpdate(clientGroup, currClientGroup);
+  const newClientGroups = new Map(currClientGroups);
+  newClientGroups.set(clientGroupID, clientGroup);
+  return setValidatedClientGroups(newClientGroups, dagWrite);
+}
+function validateClientGroupUpdate(clientGroup, currClientGroup) {
+  const mutatorNamesSet = new Set(clientGroup.mutatorNames);
+  assert(
+    mutatorNamesSet.size === clientGroup.mutatorNames.length,
+    "A client group's mutatorNames must be a set."
+  );
+  if (currClientGroup !== void 0) {
+    assert(
+      indexDefinitionsEqual(currClientGroup.indexes, clientGroup.indexes),
+      "A client group's index definitions must never change."
+    );
+    assert(
+      mutatorNamesEqual(mutatorNamesSet, currClientGroup.mutatorNames),
+      "A client group's mutatorNames must never change."
+    );
+  }
+}
+async function setValidatedClientGroups(clientGroups, dagWrite) {
+  const chunkData = clientGroupMapToChunkData(clientGroups, dagWrite);
+  const refs = /* @__PURE__ */ new Set();
+  for (const clientGroup of clientGroups.values()) {
+    refs.add(clientGroup.headHash);
   }
-  isEmpty() {
-    return this.map.isEmpty();
+  const chunk = dagWrite.createChunk(chunkData, toRefs(refs));
+  await dagWrite.putChunk(chunk);
+  await dagWrite.setHead(CLIENT_GROUPS_HEAD_NAME, chunk.hash);
+  return clientGroups;
+}
+function mutatorNamesEqual(mutatorNamesSet, mutatorNames) {
+  if (mutatorNames.length !== mutatorNamesSet.size) {
+    return false;
   }
-  getMapForIndex(indexName) {
-    const idx = this.indexes.get(indexName);
-    if (idx === void 0) {
-      throw new Error(`Unknown index name: ${indexName}`);
+  for (const mutatorName of mutatorNames) {
+    if (!mutatorNamesSet.has(mutatorName)) {
+      return false;
     }
-    return idx.map;
-  }
-  get closed() {
-    return this.#dagRead.closed;
-  }
-  close() {
-    this.#dagRead.release();
   }
-};
-function readFromDefaultHead(dagRead, formatVersion) {
-  return readFromHead(DEFAULT_HEAD_NAME, dagRead, formatVersion);
-}
-async function readFromHead(name, dagRead, formatVersion) {
-  const commit = await commitFromHead(name, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
+  return true;
 }
-async function readFromHash(hash2, dagRead, formatVersion) {
-  const commit = await commitFromHash(hash2, dagRead);
-  return readFromCommit(commit, dagRead, formatVersion);
+async function getClientGroup(id, dagRead) {
+  const clientGroups = await getClientGroups(dagRead);
+  return clientGroups.get(id);
 }
-function readFromCommit(commit, dagRead, formatVersion) {
-  const indexes = readIndexesForRead(commit, dagRead, formatVersion);
-  const map = new BTreeRead(dagRead, formatVersion, commit.valueHash);
-  return new Read(dagRead, map, indexes);
+function clientGroupHasPendingMutations(clientGroup) {
+  for (const [clientID, mutationID] of Object.entries(
+    clientGroup.mutationIDs
+  )) {
+    const lastServerAckdMutationID = clientGroup.lastServerAckdMutationIDs[clientID];
+    if (lastServerAckdMutationID === void 0 && mutationID !== 0 || lastServerAckdMutationID < mutationID) {
+      return true;
+    }
+  }
+  return false;
 }
-function readIndexesForRead(commit, dagRead, formatVersion) {
-  const m = /* @__PURE__ */ new Map();
-  for (const index of commit.indexes) {
-    m.set(
-      index.definition.name,
-      new IndexRead(
-        index,
-        new BTreeRead(dagRead, formatVersion, index.valueHash)
-      )
-    );
+async function disableClientGroup(clientGroupID, dagWrite) {
+  const clientGroup = await getClientGroup(clientGroupID, dagWrite);
+  if (!clientGroup) {
+    return;
   }
-  return m;
+  const disabledClientGroup = {
+    ...clientGroup,
+    disabled: true
+  };
+  await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
 }
 
 // ../replicache/src/async-iterable-to-array.ts
@@ -3290,73 +3290,6 @@ function makeID(row, schema) {
   return JSON.stringify(schema.primaryKey.map((k) => row[k]));
 }
 
-// ../zql/src/query/ttl.ts
-var DEFAULT_TTL_MS = 1e3 * 60 * 5;
-var DEFAULT_PRELOAD_TTL_MS = 0;
-var MAX_TTL = "10m";
-var MAX_TTL_MS = 1e3 * 60 * 10;
-var multiplier = {
-  s: 1e3,
-  m: 60 * 1e3,
-  h: 60 * 60 * 1e3,
-  d: 24 * 60 * 60 * 1e3,
-  y: 365 * 24 * 60 * 60 * 1e3
-};
-function parseTTL(ttl) {
-  if (typeof ttl === "number") {
-    return Number.isNaN(ttl) ? 0 : !Number.isFinite(ttl) || ttl < 0 ? -1 : ttl;
-  }
-  if (ttl === "none") {
-    return 0;
-  }
-  if (ttl === "forever") {
-    return -1;
-  }
-  const multi = multiplier[ttl[ttl.length - 1]];
-  return Number(ttl.slice(0, -1)) * multi;
-}
-function compareTTL(a, b) {
-  const ap = parseTTL(a);
-  const bp = parseTTL(b);
-  if (ap === -1 && bp !== -1) {
-    return 1;
-  }
-  if (ap !== -1 && bp === -1) {
-    return -1;
-  }
-  return ap - bp;
-}
-function normalizeTTL(ttl) {
-  if (typeof ttl === "string") {
-    return ttl;
-  }
-  if (ttl < 0) {
-    return "forever";
-  }
-  if (ttl === 0) {
-    return "none";
-  }
-  let shortest = ttl.toString();
-  const lengthOfNumber = shortest.length;
-  for (const unit of ["y", "d", "h", "m", "s"]) {
-    const multi = multiplier[unit];
-    const value = ttl / multi;
-    const candidate = `${value}${unit}`;
-    if (candidate.length < shortest.length) {
-      shortest = candidate;
-    }
-  }
-  return shortest.length < lengthOfNumber ? shortest : ttl;
-}
-function clampTTL(ttl, lc) {
-  const parsedTTL = parseTTL(ttl);
-  if (parsedTTL === -1 || parsedTTL > 10 * 60 * 1e3) {
-    lc?.warn?.(`TTL (${ttl}) is too high, clamping to ${MAX_TTL}`);
-    return parseTTL(MAX_TTL);
-  }
-  return parsedTTL;
-}
-
 // ../shared/src/json-schema.ts
 import * as valita from "@badrap/valita";
 var path = [];
@@ -3386,6 +3319,27 @@ var jsonObjectSchema = valita_exports.unknown().chain((v2) => {
 // ../shared/src/tdigest-schema.ts
 var tdigestSchema = valita_exports.tuple([valita_exports.number()]).concat(valita_exports.array(valita_exports.number()));
 
+// ../zero-protocol/src/data.ts
+var valueSchema = valita_exports.union(jsonSchema, valita_exports.undefined());
+var rowSchema = readonlyRecord(valueSchema);
+
+// ../zero-protocol/src/analyze-query-result.ts
+var rowCountsByQuerySchema = valita_exports.record(valita_exports.number());
+var rowCountsBySourceSchema = valita_exports.record(rowCountsByQuerySchema);
+var rowsByQuerySchema = valita_exports.record(valita_exports.array(rowSchema));
+var rowsBySourceSchema = valita_exports.record(rowsByQuerySchema);
+var analyzeQueryResultSchema = valita_exports.object({
+  warnings: valita_exports.array(valita_exports.string()),
+  syncedRows: valita_exports.record(valita_exports.array(rowSchema)).optional(),
+  syncedRowCount: valita_exports.number(),
+  start: valita_exports.number(),
+  end: valita_exports.number(),
+  afterPermissions: valita_exports.string().optional(),
+  vendedRowCounts: rowCountsBySourceSchema.optional(),
+  vendedRows: rowsBySourceSchema.optional(),
+  plans: valita_exports.record(valita_exports.array(valita_exports.string())).optional()
+});
+
 // ../zero-protocol/src/ast.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
 
@@ -3408,10 +3362,6 @@ function areEqual(arr1, arr2) {
   return arr1.length === arr2.length && arr1.every((e, i) => e === arr2[i]);
 }
 
-// ../zero-protocol/src/data.ts
-var valueSchema = valita_exports.union(jsonSchema, valita_exports.undefined());
-var rowSchema = readonlyRecord(valueSchema);
-
 // ../zero-protocol/src/ast.ts
 var selectorSchema = valita_exports.string();
 var toStaticParam = Symbol();
@@ -3509,7 +3459,8 @@ var correlationSchema = readonlyObject({
 var correlatedSubquerySchemaOmitSubquery = readonlyObject({
   correlation: correlationSchema,
   hidden: valita_exports.boolean().optional(),
-  system: literalUnion("permissions", "client", "test").optional()
+  system: literalUnion("permissions", "client", "test").optional(),
+  flip: valita_exports.boolean().optional()
 });
 var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
   subquery: valita_exports.lazy(() => astSchema)
@@ -3549,7 +3500,8 @@ function transformAST(ast, transform) {
           },
           hidden: r.hidden,
           subquery: transformAST(r.subquery, transform),
-          system: r.system
+          system: r.system,
+          flip: r.flip
         })
       )
     ) : void 0,
@@ -3756,10 +3708,20 @@ var inspectVersionDownSchema = inspectBaseDownSchema.extend({
   op: valita_exports.literal("version"),
   value: valita_exports.string()
 });
+var inspectAuthenticatedDownSchema = inspectBaseDownSchema.extend({
+  op: valita_exports.literal("authenticated"),
+  value: valita_exports.boolean()
+});
+var inspectAnalyzeQueryDownSchema = inspectBaseDownSchema.extend({
+  op: valita_exports.literal("analyze-query"),
+  value: analyzeQueryResultSchema
+});
 var inspectDownBodySchema = valita_exports.union(
   inspectQueriesDownSchema,
   inspectMetricsDownSchema,
-  inspectVersionDownSchema
+  inspectVersionDownSchema,
+  inspectAuthenticatedDownSchema,
+  inspectAnalyzeQueryDownSchema
 );
 var inspectDownMessageSchema = valita_exports.tuple([
   valita_exports.literal("inspect"),
@@ -3767,14 +3729,14 @@ var inspectDownMessageSchema = valita_exports.tuple([
 ]);
 
 // ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array6) {
-  if (array6 === null) {
+function getNonCryptoRandomValues(array7) {
+  if (array7 === null) {
     throw new TypeError("array cannot be null");
   }
-  for (let i = 0; i < array6.length; i++) {
-    array6[i] = Math.floor(Math.random() * 256);
+  for (let i = 0; i < array7.length; i++) {
+    array7[i] = Math.floor(Math.random() * 256);
   }
-  return array6;
+  return array7;
 }
 
 // ../zero-client/src/util/nanoid.ts
@@ -3851,6 +3813,56 @@ function sourceNameFromKey(key) {
   return key.slice(ENTITIES_KEY_PREFIX.length, slash);
 }
 
+// ../zero-client/src/client/inspector/client-group.ts
+var ClientGroup = class {
+  #delegate;
+  id;
+  constructor(delegate, clientGroupID) {
+    this.#delegate = delegate;
+    this.id = clientGroupID;
+  }
+  async clients() {
+    return (await this.#delegate.lazy).clientGroupClients(
+      this.#delegate,
+      this.id
+    );
+  }
+  async clientsWithQueries() {
+    return (await this.#delegate.lazy).clientGroupClientsWithQueries(
+      this.#delegate,
+      this.id
+    );
+  }
+  async queries() {
+    return (await this.#delegate.lazy).clientGroupQueries(this.#delegate);
+  }
+};
+
+// ../zero-client/src/client/inspector/client.ts
+var Client = class {
+  #delegate;
+  id;
+  clientGroup;
+  constructor(delegate, clientID, clientGroupID) {
+    this.#delegate = delegate;
+    this.id = clientID;
+    this.clientGroup = new ClientGroup(this.#delegate, clientGroupID);
+  }
+  async queries() {
+    return (await this.#delegate.lazy).clientQueries(this.#delegate, this.id);
+  }
+  async map() {
+    return (await this.#delegate.lazy).clientMap(this.#delegate, this.id);
+  }
+  async rows(tableName) {
+    return (await this.#delegate.lazy).clientRows(
+      this.#delegate,
+      this.id,
+      tableName
+    );
+  }
+};
+
 // ../shared/src/centroid.ts
 var Centroid = class {
   mean;
@@ -4154,17 +4166,128 @@ function unprocessedSize(size, compression) {
   return size;
 }
 
+// ../zero-client/src/client/inspector/inspector.ts
+var Inspector = class {
+  #delegate;
+  client;
+  clientGroup;
+  constructor(rep, delegate, getSocket) {
+    this.#delegate = {
+      getQueryMetrics: delegate.getQueryMetrics.bind(delegate),
+      getAST: delegate.getAST.bind(delegate),
+      get metrics() {
+        return delegate.metrics;
+      },
+      rep,
+      getSocket,
+      lazy: import("./lazy-inspector-TOTYUTBC.js")
+    };
+    this.client = new Client(this.#delegate, rep.clientID, rep.clientGroupID);
+    this.clientGroup = this.client.clientGroup;
+  }
+  async metrics() {
+    return (await this.#delegate.lazy).inspectorMetrics(this.#delegate);
+  }
+  async clients() {
+    return (await this.#delegate.lazy).inspectorClients(this.#delegate);
+  }
+  async clientsWithQueries() {
+    return (await this.#delegate.lazy).inspectorClientsWithQueries(
+      this.#delegate
+    );
+  }
+  async serverVersion() {
+    return (await this.#delegate.lazy).serverVersion(this.#delegate);
+  }
+};
+
 // ../zero-schema/src/table-schema.ts
 function isOneHop(r) {
   return r.length === 1;
 }
-function isTwoHop(r) {
-  return r.length === 2;
+function isTwoHop(r) {
+  return r.length === 2;
+}
+
+// ../shared/src/sentinels.ts
+function emptyFunction() {
+}
+var emptyObject = Object.freeze({});
+var emptyArray = Object.freeze([]);
+function identity(x) {
+  return x;
+}
+
+// ../zql/src/query/query.ts
+var delegateSymbol = Symbol("delegate");
+
+// ../zql/src/query/ttl.ts
+var DEFAULT_TTL_MS = 1e3 * 60 * 5;
+var DEFAULT_PRELOAD_TTL_MS = 0;
+var MAX_TTL = "10m";
+var MAX_TTL_MS = 1e3 * 60 * 10;
+var multiplier = {
+  s: 1e3,
+  m: 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3,
+  y: 365 * 24 * 60 * 60 * 1e3
+};
+function parseTTL(ttl) {
+  if (typeof ttl === "number") {
+    return Number.isNaN(ttl) ? 0 : !Number.isFinite(ttl) || ttl < 0 ? -1 : ttl;
+  }
+  if (ttl === "none") {
+    return 0;
+  }
+  if (ttl === "forever") {
+    return -1;
+  }
+  const multi = multiplier[ttl[ttl.length - 1]];
+  return Number(ttl.slice(0, -1)) * multi;
+}
+function compareTTL(a, b) {
+  const ap = parseTTL(a);
+  const bp = parseTTL(b);
+  if (ap === -1 && bp !== -1) {
+    return 1;
+  }
+  if (ap !== -1 && bp === -1) {
+    return -1;
+  }
+  return ap - bp;
+}
+function normalizeTTL(ttl) {
+  if (typeof ttl === "string") {
+    return ttl;
+  }
+  if (ttl < 0) {
+    return "forever";
+  }
+  if (ttl === 0) {
+    return "none";
+  }
+  let shortest = ttl.toString();
+  const lengthOfNumber = shortest.length;
+  for (const unit of ["y", "d", "h", "m", "s"]) {
+    const multi = multiplier[unit];
+    const value = ttl / multi;
+    const candidate = `${value}${unit}`;
+    if (candidate.length < shortest.length) {
+      shortest = candidate;
+    }
+  }
+  return shortest.length < lengthOfNumber ? shortest : ttl;
+}
+function clampTTL(ttl, lc) {
+  const parsedTTL = parseTTL(ttl);
+  if (parsedTTL === -1 || parsedTTL > 10 * 60 * 1e3) {
+    lc?.warn?.(`TTL (${ttl}) is too high, clamping to ${MAX_TTL}`);
+    return parseTTL(MAX_TTL);
+  }
+  return parsedTTL;
 }
 
-// ../zql/src/query/query.ts
-var delegateSymbol = Symbol("delegate");
-
 // ../zql/src/query/query-impl.ts
 import { resolver } from "@rocicorp/resolver";
 
@@ -4466,315 +4589,779 @@ var Exists = class {
     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);
-    }
+  /**
+   * Pushes a change if this.#filter is true for its row.
+   */
+  #pushWithFilter(change, size) {
+    if (this.#filter(change.node, size)) {
+      this.#output.push(change);
+    }
+  }
+  #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, fanOutChangeType, mergeRelationships, 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 = mergeRelationships(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"))));
+      return;
+    case "add":
+      assert(
+        types.length === 1 && types[0] === "add",
+        "Fan-in:add expected all adds"
+      );
+      output.push(addEmptyRelationships(must(candidatesToPush.get("add"))));
+      return;
+    case "edit": {
+      assert(
+        types.every(
+          (type) => type === "add" || type === "remove" || type === "edit"
+        ),
+        "Fan-in:edit expected all adds, removes, or edits"
+      );
+      const addChange = candidatesToPush.get("add");
+      const removeChange = candidatesToPush.get("remove");
+      let editChange = candidatesToPush.get("edit");
+      if (editChange) {
+        if (addChange) {
+          editChange = mergeRelationships(editChange, addChange);
+        }
+        if (removeChange) {
+          editChange = mergeRelationships(editChange, removeChange);
+        }
+        output.push(addEmptyRelationships(editChange));
+        return;
+      }
+      if (addChange && removeChange) {
+        output.push(
+          addEmptyRelationships({
+            type: "edit",
+            node: addChange.node,
+            oldNode: removeChange.node
+          })
+        );
+        return;
+      }
+      output.push(addEmptyRelationships(must(addChange ?? removeChange)));
+      return;
+    }
+    case "child": {
+      assert(
+        types.every(
+          (type) => type === "add" || // exists can change child to add or remove
+          type === "remove" || // exists can change child to add or remove
+          type === "child"
+          // other operators may preserve the child change
+        ),
+        "Fan-in:child expected all adds, removes, or children"
+      );
+      assert(
+        types.length <= 2,
+        "Fan-in:child expected at most 2 types on a child change from fan-out"
+      );
+      const childChange = candidatesToPush.get("child");
+      if (childChange) {
+        output.push(childChange);
+        return;
+      }
+      const addChange = candidatesToPush.get("add");
+      const removeChange = candidatesToPush.get("remove");
+      assert(
+        addChange === void 0 || removeChange === void 0,
+        "Fan-in:child expected either add or remove, not both"
+      );
+      output.push(addEmptyRelationships(must(addChange ?? removeChange)));
+      return;
+    }
+    default:
+      fanOutChangeType;
+  }
+}
+
+// ../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,
+      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);
+    }
+    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) {
+  const oldWasPresent = predicate(change.oldNode.row);
+  const newIsPresent = predicate(change.node.row);
+  if (oldWasPresent && newIsPresent) {
+    output.push(change);
+  } else if (oldWasPresent && !newIsPresent) {
+    output.push({
+      type: "remove",
+      node: change.oldNode
+    });
+  } else if (!oldWasPresent && newIsPresent) {
+    output.push({
+      type: "add",
+      node: change.node
+    });
+  }
+}
+
+// ../zql/src/ivm/filter-push.ts
+function filterPush(change, output, predicate) {
+  if (!predicate) {
+    output.push(change);
+    return;
+  }
+  switch (change.type) {
+    case "add":
+    case "remove":
+      if (predicate(change.node.row)) {
+        output.push(change);
+      }
+      break;
+    case "child":
+      if (predicate(change.node.row)) {
+        output.push(change);
+      }
+      break;
+    case "edit":
+      maybeSplitAndPushEditChange(change, predicate, output);
+      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);
   }
-  #getSize(node) {
-    return this.#storage.get(this.#makeSizeStorageKey(node));
+  setFilterOutput(output) {
+    this.#output = output;
   }
-  #setSize(node, size) {
-    this.#storage.set(this.#makeSizeStorageKey(node), size);
+  destroy() {
+    this.#input.destroy();
   }
-  #delSize(node) {
-    this.#storage.del(this.#makeSizeStorageKey(node));
+  getSchema() {
+    return this.#input.getSchema();
   }
-  #getOrFetchSize(node) {
-    const size = this.#getSize(node);
-    if (size !== void 0) {
-      return size;
-    }
-    return this.#fetchSize(node);
+  push(change) {
+    filterPush(change, this.#output, this.#predicate);
   }
-  #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];
+};
+
+// ../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;
+        }
       }
     }
-    const relationship = node.relationships[this.#relationshipName];
-    assert(relationship);
-    let size = 0;
-    for (const _relatedNode of relationship()) {
-      size++;
+    if (yieldNode) {
+      yield node;
     }
-    this.#setSize(node, size);
-    return size;
   }
-  #makeSizeStorageKeyPrefix(node) {
-    return `row/${this.#noSizeReuse ? "" : JSON.stringify(this.#getKeyValues(node, this.#parentJoinKey))}/`;
+  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;
+    }
   }
-  #makeSizeStorageKey(node) {
-    return `${this.#makeSizeStorageKeyPrefix(node)}${JSON.stringify(
-      this.#getKeyValues(node, this.#input.getSchema().primaryKey)
-    )}`;
+  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;
+    }
   }
-  #getKeyValues(node, def) {
-    const values = [];
-    for (const key of def) {
-      values.push(normalizeUndefined(node.row[key]));
+  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 values;
   }
-};
+  return true;
+}
 
-// ../zql/src/ivm/fan-in.ts
-var FanIn = class {
-  #inputs;
+// ../zql/src/ivm/flipped-join.ts
+var FlippedJoin = class {
+  #parent;
+  #child;
+  #parentKey;
+  #childKey;
+  #relationshipName;
   #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;
+  #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() {
-    for (const input of this.#inputs) {
-      input.destroy();
-    }
+    this.#child.destroy();
+    this.#parent.destroy();
+  }
+  setOutput(output) {
+    this.#output = output;
   }
   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."
+  // 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 compare = this.#child.getSchema().compareRows;
+      const insertPos = binarySearch(
+        childNodes.length,
+        (i) => compare(childNodes[i].row, removedNode.row)
       );
-      return;
+      childNodes.splice(insertPos, 0, removedNode);
     }
-    if (this.#accumulatedPushes.length === 0) {
-      return;
+    const parentIterators = [];
+    let threw = false;
+    try {
+      for (const childNode of childNodes) {
+        const stream = this.#parent.fetch({
+          ...req,
+          constraint: {
+            ...req.constraint,
+            ...Object.fromEntries(
+              this.#parentKey.map((key, i) => [
+                key,
+                childNode.row[this.#childKey[i]]
+              ])
+            )
+          }
+        });
+        const iterator = stream[Symbol.iterator]();
+        parentIterators.push(iterator);
+      }
+      const 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
+        )) {
+          if (this.#inprogressChildChange.change.type === "remove") {
+            if (this.#parent.getSchema().compareRows(
+              minParentNode.row,
+              this.#inprogressChildChange.position
+            ) <= 0) {
+              overlaidRelatedChildNodes = relatedChildNodes.filter(
+                (n) => n !== this.#inprogressChildChange?.change.node
+              );
+            }
+          } else if (this.#parent.getSchema().compareRows(
+            minParentNode.row,
+            this.#inprogressChildChange.position
+          ) > 0) {
+            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) {
+          }
+        }
+      }
     }
-    const candidatesToPush = /* @__PURE__ */ new Map();
-    for (const change of this.#accumulatedPushes) {
-      if (fanOutChangeType === "child" && change.type !== "child") {
+  }
+  *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
+              }
+            });
+          } else {
+            this.#output.push({
+              ...change,
+              node: {
+                ...parentNode,
+                relationships: {
+                  ...parentNode.relationships,
+                  [this.#relationshipName]: () => [change.node]
+                }
+              }
+            });
+          }
+        }
+      } finally {
+        this.#inprogressChildChange = void 0;
+      }
+    };
+    switch (change.type) {
+      case "add":
+      case "remove":
+        pushChildChange();
+        break;
+      case "edit": {
         assert(
-          candidatesToPush.has(change.type) === false,
-          () => `Fan-in:child expected at most one ${change.type} when fan-out is of type child`
+          rowEqualsForCompoundKey(
+            change.oldNode.row,
+            change.node.row,
+            this.#childKey
+          ),
+          `Child edit must not change relationship.`
         );
+        pushChildChange(true);
+        break;
       }
-      candidatesToPush.set(change.type, change);
+      case "child":
+        pushChildChange(true);
+        break;
     }
-    this.#accumulatedPushes = [];
-    const types = [...candidatesToPush.keys()];
-    switch (fanOutChangeType) {
-      case "remove":
-        assert(
-          types.length === 1 && types[0] === "remove",
-          "Fan-in:remove expected all removes"
-        );
-        this.#output.push(must(candidatesToPush.get("remove")));
-        return;
+  }
+  #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)
+      }
+    });
+    switch (change.type) {
       case "add":
-        assert(
-          types.length === 1 && types[0] === "add",
-          "Fan-in:add expected all adds"
-        );
-        this.#output.push(must(candidatesToPush.get("add")));
-        return;
+      case "remove":
+      case "child": {
+        if (first(childNodeStream(change.node)()) === void 0) {
+          return;
+        }
+        this.#output.push({
+          ...change,
+          node: flip(change.node)
+        });
+        break;
+      }
       case "edit": {
+        const oldHasChild = first(childNodeStream(change.oldNode)()) !== void 0;
+        const hasChild = first(childNodeStream(change.node)()) !== void 0;
         assert(
-          types.every(
-            (type) => type === "add" || type === "remove" || type === "edit"
+          rowEqualsForCompoundKey(
+            change.oldNode.row,
+            change.node.row,
+            this.#parentKey
           ),
-          "Fan-in:edit expected all adds, removes, or edits"
+          `Parent edit must not change relationship.`
         );
-        const addChange = candidatesToPush.get("add");
-        const removeChange = candidatesToPush.get("remove");
-        const editChange = candidatesToPush.get("edit");
-        if (editChange) {
-          this.#output.push(editChange);
-          return;
-        }
-        if (addChange && removeChange) {
+        if (oldHasChild && hasChild) {
           this.#output.push({
             type: "edit",
-            node: addChange.node,
-            oldNode: removeChange.node
+            oldNode: flip(change.oldNode),
+            node: flip(change.node)
           });
-          return;
+          break;
         }
-        this.#output.push(must(addChange ?? removeChange));
-        return;
-      }
-      case "child": {
-        assert(
-          types.every(
-            (type) => type === "add" || // exists can change child to add or remove
-            type === "remove" || // exists can change child to add or remove
-            type === "child"
-            // other operators may preserve the child change
-          ),
-          "Fan-in:child expected all adds, removes, or children"
-        );
-        assert(
-          types.length <= 2,
-          "Fan-in:child expected at most 2 types on a child change from fan-out"
-        );
-        const childChange = candidatesToPush.get("child");
-        if (childChange) {
-          this.#output.push(childChange);
-          return;
+        if (oldHasChild) {
+          this.#output.push({
+            type: "remove",
+            node: flip(change.node)
+          });
         }
-        const addChange = candidatesToPush.get("add");
-        const removeChange = candidatesToPush.get("remove");
-        assert(
-          addChange === void 0 || removeChange === void 0,
-          "Fan-in:child expected either add or remove, not both"
-        );
-        this.#output.push(must(addChange ?? removeChange));
-        return;
+        if (hasChild) {
+          this.#output.push({
+            type: "add",
+            node: flip(change.node)
+          });
+        }
+        break;
       }
       default:
-        fanOutChangeType;
-    }
-  }
-};
-
-// ../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) {
-      if (this.#destroyCount === 0) {
-        this.#input.destroy();
-      }
-      ++this.#destroyCount;
-    } 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);
+        unreachable(change);
     }
-    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) {
-  const oldWasPresent = predicate(change.oldNode.row);
-  const newIsPresent = predicate(change.node.row);
-  if (oldWasPresent && newIsPresent) {
-    output.push(change);
-  } else if (oldWasPresent && !newIsPresent) {
-    output.push({
-      type: "remove",
-      node: change.oldNode
-    });
-  } else if (!oldWasPresent && newIsPresent) {
-    output.push({
-      type: "add",
-      node: change.node
-    });
-  }
-}
-
-// ../zql/src/ivm/filter-push.ts
-function filterPush(change, output, predicate) {
-  if (!predicate) {
-    output.push(change);
-    return;
-  }
-  switch (change.type) {
-    case "add":
-    case "remove":
-      if (predicate(change.node.row)) {
-        output.push(change);
-      }
-      break;
-    case "child":
-      if (predicate(change.node.row)) {
-        output.push(change);
-      }
-      break;
-    case "edit":
-      maybeSplitAndPushEditChange(change, predicate, output);
-      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.#predicate);
   }
 };
 
@@ -4973,81 +5560,6 @@ var Join = class {
         unreachable(change);
     }
   }
-  *#generateChildStreamWithOverlay(stream, overlay) {
-    let applied = false;
-    let editOldApplied = false;
-    let editNewApplied = false;
-    for (const child of stream) {
-      let yieldChild = true;
-      if (!applied) {
-        switch (overlay.type) {
-          case "add": {
-            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) === 0) {
-              applied = true;
-              yieldChild = false;
-            }
-            break;
-          }
-          case "remove": {
-            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) < 0) {
-              applied = true;
-              yield overlay.node;
-            }
-            break;
-          }
-          case "edit": {
-            if (this.#child.getSchema().compareRows(overlay.oldNode.row, child.row) < 0) {
-              editOldApplied = true;
-              if (editNewApplied) {
-                applied = true;
-              }
-              yield overlay.oldNode;
-            }
-            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) === 0) {
-              editNewApplied = true;
-              if (editOldApplied) {
-                applied = true;
-              }
-              yieldChild = false;
-            }
-            break;
-          }
-          case "child": {
-            if (this.#child.getSchema().compareRows(overlay.node.row, child.row) === 0) {
-              applied = true;
-              yield {
-                row: child.row,
-                relationships: {
-                  ...child.relationships,
-                  [overlay.child.relationshipName]: () => this.#generateChildStreamWithOverlay(
-                    child.relationships[overlay.child.relationshipName](),
-                    overlay.child.change
-                  )
-                }
-              };
-              yieldChild = false;
-            }
-            break;
-          }
-        }
-      }
-      if (yieldChild) {
-        yield child;
-      }
-    }
-    if (!applied) {
-      if (overlay.type === "remove") {
-        applied = true;
-        yield overlay.node;
-      } else if (overlay.type === "edit") {
-        assert(editNewApplied);
-        editOldApplied = true;
-        applied = true;
-        yield overlay.oldNode;
-      }
-    }
-    assert(applied);
-  }
   #processParentNode(parentNodeRow, parentNodeRelations, mode) {
     let method = mode;
     let storageUpdated = false;
@@ -5091,16 +5603,19 @@ var Join = class {
           ])
         )
       });
-      if (this.#inprogressChildChange && this.#isJoinMatch(
+      if (this.#inprogressChildChange && isJoinMatch(
         parentNodeRow,
-        this.#inprogressChildChange.change.node.row
+        this.#parentKey,
+        this.#inprogressChildChange.change.node.row,
+        this.#childKey
       ) && this.#inprogressChildChange.position && this.#schema.compareRows(
         parentNodeRow,
         this.#inprogressChildChange.position
       ) > 0) {
-        return this.#generateChildStreamWithOverlay(
+        return generateWithOverlay(
           stream,
-          this.#inprogressChildChange.change
+          this.#inprogressChildChange.change,
+          this.#child.getSchema()
         );
       }
       return stream;
@@ -5113,14 +5628,6 @@ var Join = class {
       }
     };
   }
-  #isJoinMatch(parent, child) {
-    for (let i = 0; i < this.#parentKey.length; i++) {
-      if (!valuesEqual(parent[this.#parentKey[i]], child[this.#childKey[i]])) {
-        return false;
-      }
-    }
-    return true;
-  }
 };
 function makeStorageKeyForValues(values) {
   const json = JSON.stringify(["pKeySet", ...values]);
@@ -5136,14 +5643,6 @@ function makeStorageKey(key, primaryKey, row) {
   }
   return makeStorageKeyForValues(values);
 }
-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;
-}
 
 // ../zql/src/ivm/skip.ts
 var Skip = class {
@@ -5762,7 +6261,7 @@ var ExpressionBuilder = class {
   and = and;
   or = or;
   not = not;
-  exists = (relationship, cb) => this.#exists(relationship, cb);
+  exists = (relationship, cb, options) => this.#exists(relationship, cb, options);
 };
 function and(...conditions) {
   const expressions = filterTrue(filterUndefined(conditions));
@@ -5897,8 +6396,8 @@ var negateOperatorMap = {
 function negateOperator(op) {
   return must(negateOperatorMap[op]);
 }
-function filterUndefined(array6) {
-  return array6.filter((e) => e !== void 0);
+function filterUndefined(array7) {
+  return array7.filter((e) => e !== void 0);
 }
 function filterTrue(conditions) {
   return conditions.filter((c) => !isAlwaysTrue(c));
@@ -6284,8 +6783,16 @@ function applyCorrelatedSubQuery(sq, delegate, queryID, end, name, fromCondition
     `${name}.${sq.subquery.alias}`,
     sq.correlation.childField
   );
-  const joinName = `${name}:join(${sq.subquery.alias})`;
-  const join = new Join({
+  const joinName = `${name}:${sq.flip ? "flipped-join" : "join"}(${sq.subquery.alias})`;
+  const join = sq.flip ? new FlippedJoin({
+    parent: end,
+    child,
+    parentKey: sq.correlation.parentField,
+    childKey: sq.correlation.childField,
+    relationshipName: sq.subquery.alias,
+    hidden: sq.hidden ?? false,
+    system: sq.system ?? "client"
+  }) : new Join({
     parent: end,
     child,
     storage: delegate.createStorage(joinName),
@@ -6630,7 +7137,12 @@ var AbstractQuery = class {
     this.customQueryID,
     this.#currentJunction
   );
-  whereExists = (relationship, cb) => this.where(({ exists }) => exists(relationship, cb));
+  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(
@@ -6869,7 +7381,9 @@ var AbstractQuery = class {
       this.#currentJunction
     );
   };
-  _exists = (relationship, cb = (q) => q) => {
+  _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)) {
@@ -6901,7 +7415,8 @@ var AbstractQuery = class {
           subquery: addPrimaryKeysToAst(
             this.#schema.tables[destSchema],
             sq._ast
-          )
+          ),
+          flip
         },
         op: "EXISTS"
       };
@@ -6936,6 +7451,7 @@ var AbstractQuery = class {
             parentField: firstRelation.sourceField,
             childField: firstRelation.destField
           },
+          flip,
           subquery: {
             table: junctionSchema,
             alias: `${SUBQ_PREFIX}${relationship}`,
@@ -6954,7 +7470,8 @@ var AbstractQuery = class {
                 subquery: addPrimaryKeysToAst(
                   this.#schema.tables[destSchema],
                   queryToDest._ast
-                )
+                ),
+                flip
               },
               op: "EXISTS"
             }
@@ -6998,9 +7515,6 @@ var AbstractQuery = class {
     }
     return this.#completedAST;
   }
-  then(onFulfilled, onRejected) {
-    return this.run().then(onFulfilled, onRejected);
-  }
 };
 var completedAstSymbol = Symbol();
 var QueryImpl = class _QueryImpl extends AbstractQuery {
@@ -7222,16 +7736,6 @@ export {
   ChunkNotFoundError,
   mustGetChunk,
   mustGetHeadHash,
-  withRead,
-  withWriteNoImplicitCommit,
-  withWrite,
-  using,
-  getClientGroups,
-  setClientGroups,
-  setClientGroup,
-  getClientGroup,
-  clientGroupHasPendingMutations,
-  disableClientGroup,
   binarySearch,
   joinIterables,
   once,
@@ -7268,6 +7772,16 @@ export {
   newWriteSnapshotDD31,
   clientGroupIDSchema,
   clientIDSchema,
+  withRead,
+  withWriteNoImplicitCommit,
+  withWrite,
+  using,
+  getClientGroups,
+  setClientGroups,
+  setClientGroup,
+  getClientGroup,
+  clientGroupHasPendingMutations,
+  disableClientGroup,
   makeClientID,
   assertClientV6,
   getClients,
@@ -7300,6 +7814,8 @@ export {
   makeComparator,
   valuesEqual,
   throwOutput,
+  emptyFunction,
+  emptyObject,
   filterPush,
   ExpressionBuilder,
   createPredicate,
@@ -7323,6 +7839,8 @@ export {
   inspectQueriesDownSchema,
   inspectMetricsDownSchema,
   inspectVersionDownSchema,
+  inspectAuthenticatedDownSchema,
+  inspectAnalyzeQueryDownSchema,
   inspectDownMessageSchema,
   primaryKeySchema,
   primaryKeyValueRecordSchema,
@@ -7336,6 +7854,8 @@ export {
   toMutationResponseKey,
   toPrimaryKeyString,
   sourceNameFromKey,
-  TDigest
+  Client,
+  TDigest,
+  Inspector
 };
-//# sourceMappingURL=chunk-MLYQCVBG.js.map
+//# sourceMappingURL=chunk-QZPMFA73.js.map