@rocicorp/zero 0.24.2025091200 → 0.24.2025092400

package/out/{chunk-K5ZSWG54.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,28 +236,6 @@ 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;
-  }
-};
-async function mustGetChunk(store, hash2) {
-  const chunk = await store.getChunk(hash2);
-  if (chunk) {
-    return chunk;
-  }
-  throw new ChunkNotFoundError(hash2);
-}
-async function mustGetHeadHash(name, store) {
-  const hash2 = await store.getHead(name);
-  assert(hash2, `Missing head ${name}`);
-  return hash2;
-}
-
 // ../shared/src/json.ts
 function deepEqual(a, b) {
   if (a === b) {
@@ -698,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;
 }
@@ -1359,6 +1337,28 @@ function createChunk(data, refs, chunkHasher) {
   return new Chunk(hash2, data, refs);
 }
 
+// ../replicache/src/dag/store.ts
+var ChunkNotFoundError = class extends Error {
+  name = "ChunkNotFoundError";
+  hash;
+  constructor(hash2) {
+    super(`Chunk not found ${hash2}`);
+    this.hash = hash2;
+  }
+};
+async function mustGetChunk(store, hash2) {
+  const chunk = await store.getChunk(hash2);
+  if (chunk) {
+    return chunk;
+  }
+  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
 var LocalDD31 = 4;
 var SnapshotDD31 = 5;
@@ -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,
@@ -3760,11 +3712,16 @@ 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,
-  inspectAuthenticatedDownSchema
+  inspectAuthenticatedDownSchema,
+  inspectAnalyzeQueryDownSchema
 );
 var inspectDownMessageSchema = valita_exports.tuple([
   valita_exports.literal("inspect"),
@@ -3772,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
@@ -3856,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;
@@ -4159,6 +4166,41 @@ 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;
@@ -4167,9 +4209,85 @@ 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-impl.ts
 import { resolver } from "@rocicorp/resolver";
 
@@ -4533,132 +4651,156 @@ var Exists = class {
   }
 };
 
-// ../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;
+// ../zql/src/ivm/push-accumulated.ts
+function pushAccumulatedChanges(accumulatedPushes, output, fanOutChangeType, mergeRelationships, addEmptyRelationships) {
+  if (accumulatedPushes.length === 0) {
+    return;
   }
-  destroy() {
-    for (const input of this.#inputs) {
-      input.destroy();
+  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);
   }
-  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) {
+  accumulatedPushes.length = 0;
+  const types = [...candidatesToPush.keys()];
+  switch (fanOutChangeType) {
+    case "remove":
       assert(
-        this.#accumulatedPushes.length === 0,
-        "If there are no inputs then fan-in should not receive any pushes."
+        types.length === 1 && types[0] === "remove",
+        "Fan-in:remove expected all removes"
       );
+      output.push(addEmptyRelationships(must(candidatesToPush.get("remove"))));
       return;
-    }
-    if (this.#accumulatedPushes.length === 0) {
-      return;
-    }
-    const candidatesToPush = /* @__PURE__ */ new Map();
-    for (const change of this.#accumulatedPushes) {
-      if (fanOutChangeType === "child" && change.type !== "child") {
-        assert(
-          candidatesToPush.has(change.type) === false,
-          () => `Fan-in:child expected at most one ${change.type} when fan-out is of type child`
-        );
-      }
-      candidatesToPush.set(change.type, change);
-    }
-    this.#accumulatedPushes = [];
-    const types = [...candidatesToPush.keys()];
-    switch (fanOutChangeType) {
-      case "remove":
-        assert(
-          types.length === 1 && types[0] === "remove",
-          "Fan-in:remove expected all removes"
-        );
-        this.#output.push(must(candidatesToPush.get("remove")));
-        return;
-      case "add":
-        assert(
-          types.length === 1 && types[0] === "add",
-          "Fan-in:add expected all adds"
-        );
-        this.#output.push(must(candidatesToPush.get("add")));
-        return;
-      case "edit": {
-        assert(
-          types.every(
-            (type) => type === "add" || type === "remove" || type === "edit"
-          ),
-          "Fan-in:edit expected all adds, removes, or edits"
-        );
-        const addChange = candidatesToPush.get("add");
-        const removeChange = candidatesToPush.get("remove");
-        const editChange = candidatesToPush.get("edit");
-        if (editChange) {
-          this.#output.push(editChange);
-          return;
+    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 (addChange && removeChange) {
-          this.#output.push({
+        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;
-        }
-        this.#output.push(must(addChange ?? removeChange));
+          })
+        );
         return;
       }
-      case "child": {
-        assert(
-          types.every(
-            (type) => type === "add" || // exists can change child to add or remove
-            type === "remove" || // exists can change child to add or remove
-            type === "child"
-            // other operators may preserve the child change
-          ),
-          "Fan-in:child expected all adds, removes, or children"
-        );
-        assert(
-          types.length <= 2,
-          "Fan-in:child expected at most 2 types on a child change from fan-out"
-        );
-        const childChange = candidatesToPush.get("child");
-        if (childChange) {
-          this.#output.push(childChange);
-          return;
-        }
-        const addChange = candidatesToPush.get("add");
-        const removeChange = candidatesToPush.get("remove");
-        assert(
-          addChange === void 0 || removeChange === void 0,
-          "Fan-in:child expected either add or remove, not both"
-        );
-        this.#output.push(must(addChange ?? removeChange));
+      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;
       }
-      default:
-        fanOutChangeType;
+      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
@@ -4679,10 +4821,10 @@ var FanOut = class {
   }
   destroy() {
     if (this.#destroyCount < this.#outputs.length) {
-      if (this.#destroyCount === 0) {
+      ++this.#destroyCount;
+      if (this.#destroyCount === this.#outputs.length) {
         this.#input.destroy();
       }
-      ++this.#destroyCount;
     } else {
       throw new Error("FanOut already destroyed once for each output");
     }
@@ -4783,6 +4925,446 @@ var Filter = class {
   }
 };
 
+// ../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 compare = this.#child.getSchema().compareRows;
+      const insertPos = binarySearch(
+        childNodes.length,
+        (i) => compare(childNodes[i].row, removedNode.row)
+      );
+      childNodes.splice(insertPos, 0, removedNode);
+    }
+    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) {
+          }
+        }
+      }
+    }
+  }
+  *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(
+          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)
+      }
+    });
+    switch (change.type) {
+      case "add":
+      case "remove":
+      case "child": {
+        if (first(childNodeStream(change.node)()) === void 0) {
+          return;
+        }
+        this.#output.push({
+          ...change,
+          node: flip(change.node)
+        });
+        break;
+      }
+      case "edit": {
+        const oldHasChild = first(childNodeStream(change.oldNode)()) !== void 0;
+        const hasChild = first(childNodeStream(change.node)()) !== void 0;
+        assert(
+          rowEqualsForCompoundKey(
+            change.oldNode.row,
+            change.node.row,
+            this.#parentKey
+          ),
+          `Parent edit must not change relationship.`
+        );
+        if (oldHasChild && hasChild) {
+          this.#output.push({
+            type: "edit",
+            oldNode: flip(change.oldNode),
+            node: flip(change.node)
+          });
+          break;
+        }
+        if (oldHasChild) {
+          this.#output.push({
+            type: "remove",
+            node: flip(change.node)
+          });
+        }
+        if (hasChild) {
+          this.#output.push({
+            type: "add",
+            node: flip(change.node)
+          });
+        }
+        break;
+      }
+      default:
+        unreachable(change);
+    }
+  }
+};
+
 // ../zql/src/ivm/join.ts
 var Join = class {
   #parent;
@@ -4978,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;
@@ -5096,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;
@@ -5118,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]);
@@ -5141,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 {
@@ -5767,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));
@@ -5902,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));
@@ -6289,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),
@@ -6635,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(
@@ -6874,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)) {
@@ -6906,7 +7415,8 @@ var AbstractQuery = class {
           subquery: addPrimaryKeysToAst(
             this.#schema.tables[destSchema],
             sq._ast
-          )
+          ),
+          flip
         },
         op: "EXISTS"
       };
@@ -6941,6 +7451,7 @@ var AbstractQuery = class {
             parentField: firstRelation.sourceField,
             childField: firstRelation.destField
           },
+          flip,
           subquery: {
             table: junctionSchema,
             alias: `${SUBQ_PREFIX}${relationship}`,
@@ -6959,7 +7470,8 @@ var AbstractQuery = class {
                 subquery: addPrimaryKeysToAst(
                   this.#schema.tables[destSchema],
                   queryToDest._ast
-                )
+                ),
+                flip
               },
               op: "EXISTS"
             }
@@ -7003,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 {
@@ -7305,6 +7814,8 @@ export {
   makeComparator,
   valuesEqual,
   throwOutput,
+  emptyFunction,
+  emptyObject,
   filterPush,
   ExpressionBuilder,
   createPredicate,
@@ -7329,6 +7840,7 @@ export {
   inspectMetricsDownSchema,
   inspectVersionDownSchema,
   inspectAuthenticatedDownSchema,
+  inspectAnalyzeQueryDownSchema,
   inspectDownMessageSchema,
   primaryKeySchema,
   primaryKeyValueRecordSchema,
@@ -7342,6 +7854,8 @@ export {
   toMutationResponseKey,
   toPrimaryKeyString,
   sourceNameFromKey,
-  TDigest
+  Client,
+  TDigest,
+  Inspector
 };
-//# sourceMappingURL=chunk-K5ZSWG54.js.map
+//# sourceMappingURL=chunk-QZPMFA73.js.map