@rocicorp/zero 0.23.2025081401 → 0.23.2025081901

package/out/{chunk-O536GEIT.js → chunk-RPVWLROJ.js}

@@ -3721,7 +3721,8 @@ function compareUTF8MaybeNull(a, b) {
 
 // ../zero-protocol/src/inspect-down.ts
 var serverMetricsSchema = valita_exports.object({
-  "query-materialization-server": tdigestSchema
+  "query-materialization-server": tdigestSchema,
+  "query-update-server": tdigestSchema
 });
 var inspectQueryRowSchema = valita_exports.object({
   clientID: valita_exports.string(),
@@ -4260,9 +4261,14 @@ var FilterEnd = class {
     this.#output.push(change);
   }
 };
-function buildFilterPipeline(input, pipeline) {
+function buildFilterPipeline(input, delegate, pipeline) {
   const filterStart = new FilterStart(input);
-  return new FilterEnd(filterStart, pipeline(filterStart));
+  delegate.addEdge(input, filterStart);
+  const middle = pipeline(filterStart);
+  delegate.addEdge(filterStart, middle);
+  const filterEnd = new FilterEnd(filterStart, middle);
+  delegate.addEdge(middle, filterEnd);
+  return filterEnd;
 }
 
 // ../zql/src/ivm/operator.ts
@@ -6124,25 +6130,36 @@ function buildPipelineInternal(ast, delegate, queryID, name, partitionKey) {
       }
     }
   }
-  const conn = source.connect(must(ast.orderBy), ast.where, splitEditKeys);
+  const conn = source.connect(
+    must(ast.orderBy),
+    ast.where,
+    splitEditKeys,
+    delegate.debug
+  );
   let end = delegate.decorateSourceInput(conn, queryID);
   end = delegate.decorateInput(end, `${name}:source(${ast.table})`);
   const { fullyAppliedFilters } = conn;
   if (ast.start) {
-    end = delegate.decorateInput(new Skip(end, ast.start), `${name}:skip)`);
+    const skip = new Skip(end, ast.start);
+    delegate.addEdge(end, skip);
+    end = delegate.decorateInput(skip, `${name}:skip)`);
   }
   for (const csq of csqsFromCondition) {
     end = applyCorrelatedSubQuery(csq, delegate, queryID, end, name, true);
   }
-  if (ast.where && !fullyAppliedFilters) {
+  if (ast.where && (!fullyAppliedFilters || delegate.applyFiltersAnyway)) {
     end = applyWhere(end, ast.where, delegate, name);
   }
   if (ast.limit !== void 0) {
     const takeName = `${name}:take`;
-    end = delegate.decorateInput(
-      new Take(end, delegate.createStorage(takeName), ast.limit, partitionKey),
-      takeName
+    const take2 = new Take(
+      end,
+      delegate.createStorage(takeName),
+      ast.limit,
+      partitionKey
     );
+    delegate.addEdge(end, take2);
+    end = delegate.decorateInput(take2, takeName);
   }
   if (ast.related) {
     for (const csq of ast.related) {
@@ -6154,6 +6171,7 @@ function buildPipelineInternal(ast, delegate, queryID, name, partitionKey) {
 function applyWhere(input, condition, delegate, name) {
   return buildFilterPipeline(
     input,
+    delegate,
     (filterInput) => applyFilter(filterInput, condition, delegate, name)
   );
 }
@@ -6166,7 +6184,7 @@ function applyFilter(input, condition, delegate, name) {
     case "correlatedSubquery":
       return applyCorrelatedSubqueryCondition(input, condition, delegate, name);
     case "simple":
-      return applySimpleCondition(input, condition);
+      return applySimpleCondition(input, delegate, condition);
   }
 }
 function applyAnd(input, condition, delegate, name) {
@@ -6178,30 +6196,36 @@ function applyAnd(input, condition, delegate, name) {
 function applyOr(input, condition, delegate, name) {
   const [subqueryConditions, otherConditions] = groupSubqueryConditions(condition);
   if (subqueryConditions.length === 0) {
-    return new Filter(
+    const filter = new Filter(
       input,
       createPredicate({
         type: "or",
         conditions: otherConditions
       })
     );
+    delegate.addEdge(input, filter);
+    return filter;
   }
   const fanOut = new FanOut(input);
+  delegate.addEdge(input, fanOut);
   const branches = subqueryConditions.map(
     (subCondition) => applyFilter(fanOut, subCondition, delegate, name)
   );
   if (otherConditions.length > 0) {
-    branches.push(
-      new Filter(
-        fanOut,
-        createPredicate({
-          type: "or",
-          conditions: otherConditions
-        })
-      )
+    const filter = new Filter(
+      fanOut,
+      createPredicate({
+        type: "or",
+        conditions: otherConditions
+      })
     );
+    delegate.addEdge(fanOut, filter);
+    branches.push(filter);
   }
   const ret = new FanIn(fanOut, branches);
+  for (const branch of branches) {
+    delegate.addEdge(branch, ret);
+  }
   fanOut.setFanIn(ret);
   return ret;
 }
@@ -6225,8 +6249,24 @@ function isNotAndDoesNotContainSubquery(condition) {
   }
   return condition.conditions.every(isNotAndDoesNotContainSubquery);
 }
-function applySimpleCondition(input, condition) {
-  return new Filter(input, createPredicate(condition));
+function applySimpleCondition(input, delegate, condition) {
+  const filter = new Filter(input, createPredicate(condition));
+  delegate.decorateFilterInput(
+    filter,
+    `${valuePosName(condition.left)}:${condition.op}:${valuePosName(condition.right)}`
+  );
+  delegate.addEdge(input, filter);
+  return filter;
+}
+function valuePosName(left) {
+  switch (left.type) {
+    case "static":
+      return left.field;
+    case "literal":
+      return left.value;
+    case "column":
+      return left.name;
+  }
 }
 function applyCorrelatedSubQuery(sq, delegate, queryID, end, name, fromCondition) {
   if (sq.subquery.limit === 0 && fromCondition) {
@@ -6241,7 +6281,7 @@ function applyCorrelatedSubQuery(sq, delegate, queryID, end, name, fromCondition
     sq.correlation.childField
   );
   const joinName = `${name}:join(${sq.subquery.alias})`;
-  end = new Join({
+  const join = new Join({
     parent: end,
     child,
     storage: delegate.createStorage(joinName),
@@ -6251,27 +6291,32 @@ function applyCorrelatedSubQuery(sq, delegate, queryID, end, name, fromCondition
     hidden: sq.hidden ?? false,
     system: sq.system ?? "client"
   });
-  return delegate.decorateInput(end, joinName);
+  delegate.addEdge(end, join);
+  delegate.addEdge(child, join);
+  return delegate.decorateInput(join, joinName);
 }
 function applyCorrelatedSubqueryCondition(input, condition, delegate, name) {
   assert(condition.op === "EXISTS" || condition.op === "NOT EXISTS");
   if (condition.related.subquery.limit === 0) {
     if (condition.op === "EXISTS") {
-      return new Filter(input, () => false);
+      const filter2 = new Filter(input, () => false);
+      delegate.addEdge(input, filter2);
+      return filter2;
     }
-    return new Filter(input, () => true);
+    const filter = new Filter(input, () => true);
+    delegate.addEdge(input, filter);
+    return filter;
   }
   const existsName = `${name}:exists(${condition.related.subquery.alias})`;
-  return delegate.decorateFilterInput(
-    new Exists(
-      input,
-      delegate.createStorage(existsName),
-      must(condition.related.subquery.alias),
-      condition.related.correlation.parentField,
-      condition.op
-    ),
-    existsName
+  const exists = new Exists(
+    input,
+    delegate.createStorage(existsName),
+    must(condition.related.subquery.alias),
+    condition.related.correlation.parentField,
+    condition.op
   );
+  delegate.addEdge(input, exists);
+  return delegate.decorateFilterInput(exists, existsName);
 }
 function gatherCorrelatedSubqueryQueriesFromCondition(condition) {
   const csqs = [];
@@ -7266,4 +7311,4 @@ export {
   sourceNameFromKey,
   TDigest
 };
-//# sourceMappingURL=chunk-O536GEIT.js.map
+//# sourceMappingURL=chunk-RPVWLROJ.js.map