@rocicorp/zero 0.22.2025081301 → 0.23.2025081400

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

@@ -1,60 +1,22 @@
+import {
+  assert,
+  assertArray,
+  assertBoolean,
+  assertDeepFrozen,
+  assertNumber,
+  assertObject,
+  assertString,
+  deepFreeze,
+  hasOwn,
+  isProd,
+  throwInvalidType,
+  unreachable
+} from "./chunk-SGW2EIVJ.js";
 import {
   __export,
   __reExport
 } from "./chunk-424PT5DM.js";
 
-// ../shared/src/asserts.ts
-function assert(b, msg = "Assertion failed") {
-  if (!b) {
-    throw new Error(typeof msg === "string" ? msg : msg());
-  }
-}
-function assertString(v2) {
-  assertType(v2, "string");
-}
-function assertNumber(v2) {
-  assertType(v2, "number");
-}
-function assertBoolean(v2) {
-  assertType(v2, "boolean");
-}
-function assertType(v2, t) {
-  if (typeof v2 !== t) {
-    throwInvalidType(v2, t);
-  }
-}
-function assertObject(v2) {
-  if (v2 === null) {
-    throwInvalidType(v2, "object");
-  }
-  assertType(v2, "object");
-}
-function assertArray(v2) {
-  if (!Array.isArray(v2)) {
-    throwInvalidType(v2, "array");
-  }
-}
-function invalidType(v2, t) {
-  let s = "Invalid type: ";
-  if (v2 === null || v2 === void 0) {
-    s += v2;
-  } else {
-    s += `${typeof v2} \`${v2}\``;
-  }
-  return s + `, expected ${t}`;
-}
-function throwInvalidType(v2, t) {
-  throw new Error(invalidType(v2, t));
-}
-function assertNotNull(v2) {
-  if (v2 === null) {
-    throw new Error("Expected non-null value");
-  }
-}
-function unreachable(_) {
-  throw new Error("Unreachable");
-}
-
 // ../shared/src/valita.ts
 var valita_exports = {};
 __export(valita_exports, {
@@ -296,12 +258,6 @@ var V6 = 6;
 var V7 = 7;
 var Latest = V7;
 
-// ../shared/src/config.ts
-var isProd = process.env.NODE_ENV === "production";
-
-// ../shared/src/has-own.ts
-var { hasOwn } = Object;
-
 // ../shared/src/json.ts
 function deepEqual(a, b) {
   if (a === b) {
@@ -599,123 +555,6 @@ function wrapIterable(iter) {
   return new IterWrapper(iter);
 }
 
-// ../replicache/src/frozen-json.ts
-var deepFrozenObjects = /* @__PURE__ */ new WeakSet();
-function deepFreeze(v2) {
-  if (isProd) {
-    return v2;
-  }
-  deepFreezeInternal(v2, []);
-  return v2;
-}
-function deepFreezeInternal(v2, seen) {
-  switch (typeof v2) {
-    case "undefined":
-      throw new TypeError("Unexpected value undefined");
-    case "boolean":
-    case "number":
-    case "string":
-      return;
-    case "object": {
-      if (v2 === null) {
-        return;
-      }
-      if (deepFrozenObjects.has(v2)) {
-        return;
-      }
-      deepFrozenObjects.add(v2);
-      if (seen.includes(v2)) {
-        throwInvalidType(v2, "Cyclic JSON object");
-      }
-      seen.push(v2);
-      Object.freeze(v2);
-      if (Array.isArray(v2)) {
-        deepFreezeArray(v2, seen);
-      } else {
-        deepFreezeObject(v2, seen);
-      }
-      seen.pop();
-      return;
-    }
-    default:
-      throwInvalidType(v2, "JSON value");
-  }
-}
-function deepFreezeArray(v2, seen) {
-  for (const item of v2) {
-    deepFreezeInternal(item, seen);
-  }
-}
-function deepFreezeObject(v2, seen) {
-  for (const k in v2) {
-    if (hasOwn(v2, k)) {
-      const value = v2[k];
-      if (value !== void 0) {
-        deepFreezeInternal(value, seen);
-      }
-    }
-  }
-}
-function assertDeepFrozen(v2) {
-  if (isProd) {
-    return;
-  }
-  if (!isDeepFrozen(v2, [])) {
-    throw new Error("Expected frozen object");
-  }
-}
-function isDeepFrozen(v2, seen) {
-  switch (typeof v2) {
-    case "boolean":
-    case "number":
-    case "string":
-      return true;
-    case "object":
-      if (v2 === null) {
-        return true;
-      }
-      if (deepFrozenObjects.has(v2)) {
-        return true;
-      }
-      if (!Object.isFrozen(v2)) {
-        return false;
-      }
-      if (seen.includes(v2)) {
-        throwInvalidType(v2, "Cyclic JSON object");
-      }
-      seen.push(v2);
-      if (Array.isArray(v2)) {
-        for (const item of v2) {
-          if (!isDeepFrozen(item, seen)) {
-            seen.pop();
-            return false;
-          }
-        }
-      } else {
-        for (const k in v2) {
-          if (hasOwn(v2, k)) {
-            const value = v2[k];
-            if (value !== void 0 && !isDeepFrozen(value, seen)) {
-              seen.pop();
-              return false;
-            }
-          }
-        }
-      }
-      deepFrozenObjects.add(v2);
-      seen.pop();
-      return true;
-    default:
-      throwInvalidType(v2, "JSON value");
-  }
-}
-function deepFreezeAllowUndefined(v2) {
-  if (v2 === void 0) {
-    return void 0;
-  }
-  return deepFreeze(v2);
-}
-
 // ../replicache/src/btree/node.ts
 var NODE_LEVEL = 0;
 var NODE_ENTRIES = 1;
@@ -859,13 +698,13 @@ var DataNodeImpl = class extends NodeImpl {
     }
   }
 };
-function readonlySplice(array5, start, deleteCount, ...items) {
-  const arr = array5.slice(0, start);
+function readonlySplice(array6, start, deleteCount, ...items) {
+  const arr = array6.slice(0, start);
   for (let i = 0; i < items.length; i++) {
     arr.push(items[i]);
   }
-  for (let i = start + deleteCount; i < array5.length; i++) {
-    arr.push(array5[i]);
+  for (let i = start + deleteCount; i < array6.length; i++) {
+    arr.push(array6[i]);
   }
   return arr;
 }
@@ -3095,6 +2934,26 @@ async function setClients(clients, dagWrite) {
   return chunk.hash;
 }
 
+// ../shared/src/objects.ts
+function mapValues(input, mapper) {
+  return mapEntries(input, (k, v2) => [k, mapper(v2)]);
+}
+function mapEntries(input, mapper) {
+  const output = {};
+  for (const entry of Object.entries(input)) {
+    const mapped = mapper(entry[0], entry[1]);
+    output[mapped[0]] = mapped[1];
+  }
+  return output;
+}
+function mapAllEntries(input, mapper) {
+  const output = {};
+  for (const mapped of mapper(Object.entries(input))) {
+    output[mapped[0]] = mapped[1];
+  }
+  return output;
+}
+
 // ../shared/src/must.ts
 function must(v2, msg) {
   if (v2 == null) {
@@ -3524,6 +3383,9 @@ var jsonObjectSchema = valita_exports.unknown().chain((v2) => {
   return rv;
 });
 
+// ../shared/src/tdigest-schema.ts
+var tdigestSchema = valita_exports.tuple([valita_exports.number()]).concat(valita_exports.array(valita_exports.number()));
+
 // ../zero-protocol/src/ast.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
 
@@ -3858,6 +3720,9 @@ function compareUTF8MaybeNull(a, b) {
 }
 
 // ../zero-protocol/src/inspect-down.ts
+var serverMetricsSchema = valita_exports.object({
+  "query-materialization-server": tdigestSchema
+});
 var inspectQueryRowSchema = valita_exports.object({
   clientID: valita_exports.string(),
   queryID: valita_exports.string(),
@@ -3871,28 +3736,43 @@ var inspectQueryRowSchema = valita_exports.object({
   deleted: valita_exports.boolean(),
   ttl: valita_exports.number(),
   inactivatedAt: valita_exports.number().nullable(),
-  rowCount: valita_exports.number()
+  rowCount: valita_exports.number(),
+  metrics: serverMetricsSchema.nullable().optional()
+});
+var inspectBaseDownSchema = valita_exports.object({
+  id: valita_exports.string()
 });
-var inspectQueriesDownSchema = valita_exports.object({
+var inspectQueriesDownSchema = inspectBaseDownSchema.extend({
   op: valita_exports.literal("queries"),
-  id: valita_exports.string(),
   value: valita_exports.array(inspectQueryRowSchema)
 });
-var inspectDownBodySchema = valita_exports.union(inspectQueriesDownSchema);
+var inspectMetricsDownSchema = inspectBaseDownSchema.extend({
+  op: valita_exports.literal("metrics"),
+  value: serverMetricsSchema
+});
+var inspectVersionDownSchema = inspectBaseDownSchema.extend({
+  op: valita_exports.literal("version"),
+  value: valita_exports.string()
+});
+var inspectDownBodySchema = valita_exports.union(
+  inspectQueriesDownSchema,
+  inspectMetricsDownSchema,
+  inspectVersionDownSchema
+);
 var inspectDownMessageSchema = valita_exports.tuple([
   valita_exports.literal("inspect"),
   inspectDownBodySchema
 ]);
 
 // ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array5) {
-  if (array5 === null) {
+function getNonCryptoRandomValues(array6) {
+  if (array6 === null) {
     throw new TypeError("array cannot be null");
   }
-  for (let i = 0; i < array5.length; i++) {
-    array5[i] = Math.floor(Math.random() * 256);
+  for (let i = 0; i < array6.length; i++) {
+    array6[i] = Math.floor(Math.random() * 256);
   }
-  return array5;
+  return array6;
 }
 
 // ../zero-client/src/util/nanoid.ts
@@ -3969,6 +3849,309 @@ function sourceNameFromKey(key) {
   return key.slice(ENTITIES_KEY_PREFIX.length, slash);
 }
 
+// ../shared/src/centroid.ts
+var Centroid = class {
+  mean;
+  weight;
+  constructor(mean, weight) {
+    this.mean = mean;
+    this.weight = weight;
+  }
+  add(r) {
+    if (r.weight < 0) {
+      throw new Error("centroid weight cannot be less than zero");
+    }
+    if (this.weight !== 0) {
+      this.weight += r.weight;
+      this.mean += r.weight * (r.mean - this.mean) / this.weight;
+    } else {
+      this.weight = r.weight;
+      this.mean = r.mean;
+    }
+  }
+};
+function sortCentroidList(centroids) {
+  centroids.sort((a, b) => a.mean - b.mean);
+}
+
+// ../shared/src/tdigest.ts
+var TDigest = class _TDigest {
+  compression;
+  #maxProcessed;
+  #maxUnprocessed;
+  #processed;
+  #unprocessed;
+  #cumulative;
+  #processedWeight;
+  #unprocessedWeight;
+  #min;
+  #max;
+  constructor(compression = 1e3) {
+    this.compression = compression;
+    this.#maxProcessed = processedSize(0, this.compression);
+    this.#maxUnprocessed = unprocessedSize(0, this.compression);
+    this.reset();
+  }
+  /**
+   * fromJSON creates a TDigest from a JSON-serializable representation.
+   * The data should be an object with compression and centroids array.
+   */
+  static fromJSON(data) {
+    const digest = new _TDigest(data[0]);
+    if (data.length % 2 !== 1) {
+      throw new Error("Invalid centroids array");
+    }
+    for (let i = 1; i < data.length; i += 2) {
+      digest.add(data[i], data[i + 1]);
+    }
+    return digest;
+  }
+  reset() {
+    this.#processed = [];
+    this.#unprocessed = [];
+    this.#cumulative = [];
+    this.#processedWeight = 0;
+    this.#unprocessedWeight = 0;
+    this.#min = Number.MAX_VALUE;
+    this.#max = -Number.MAX_VALUE;
+  }
+  add(mean, weight = 1) {
+    this.addCentroid(new Centroid(mean, weight));
+  }
+  /** AddCentroidList can quickly add multiple centroids. */
+  addCentroidList(centroidList) {
+    for (const c of centroidList) {
+      this.addCentroid(c);
+    }
+  }
+  /**
+   * AddCentroid adds a single centroid.
+   * Weights which are not a number or are <= 0 are ignored, as are NaN means.
+   */
+  addCentroid(c) {
+    if (Number.isNaN(c.mean) || c.weight <= 0 || Number.isNaN(c.weight) || !Number.isFinite(c.weight)) {
+      return;
+    }
+    this.#unprocessed.push(new Centroid(c.mean, c.weight));
+    this.#unprocessedWeight += c.weight;
+    if (this.#processed.length > this.#maxProcessed || this.#unprocessed.length > this.#maxUnprocessed) {
+      this.#process();
+    }
+  }
+  /**
+   *  Merges the supplied digest into this digest. Functionally equivalent to
+   * calling t.AddCentroidList(t2.Centroids(nil)), but avoids making an extra
+   * copy of the CentroidList.
+   **/
+  merge(t2) {
+    t2.#process();
+    this.addCentroidList(t2.#processed);
+  }
+  #process() {
+    if (this.#unprocessed.length > 0 || this.#processed.length > this.#maxProcessed) {
+      this.#unprocessed.push(...this.#processed);
+      sortCentroidList(this.#unprocessed);
+      this.#processed.length = 0;
+      this.#processed.push(this.#unprocessed[0]);
+      this.#processedWeight += this.#unprocessedWeight;
+      this.#unprocessedWeight = 0;
+      let soFar = this.#unprocessed[0].weight;
+      let limit = this.#processedWeight * this.#integratedQ(1);
+      for (let i = 1; i < this.#unprocessed.length; i++) {
+        const centroid = this.#unprocessed[i];
+        const projected = soFar + centroid.weight;
+        if (projected <= limit) {
+          soFar = projected;
+          this.#processed[this.#processed.length - 1].add(centroid);
+        } else {
+          const k1 = this.#integratedLocation(soFar / this.#processedWeight);
+          limit = this.#processedWeight * this.#integratedQ(k1 + 1);
+          soFar += centroid.weight;
+          this.#processed.push(centroid);
+        }
+      }
+      this.#min = Math.min(this.#min, this.#processed[0].mean);
+      this.#max = Math.max(
+        this.#max,
+        this.#processed[this.#processed.length - 1].mean
+      );
+      this.#unprocessed.length = 0;
+    }
+  }
+  /**
+   * Centroids returns a copy of processed centroids.
+   * Useful when aggregating multiple t-digests.
+   *
+   * Centroids are appended to the passed CentroidList; if you're re-using a
+   * buffer, be sure to pass cl[:0].
+   */
+  centroids(cl = []) {
+    this.#process();
+    return cl.concat(this.#processed);
+  }
+  count() {
+    this.#process();
+    return this.#processedWeight;
+  }
+  /**
+   * toJSON returns a JSON-serializable representation of the digest.
+   * This processes the digest and returns an object with compression and centroid data.
+   */
+  toJSON() {
+    this.#process();
+    const data = [this.compression];
+    for (const centroid of this.#processed) {
+      data.push(centroid.mean, centroid.weight);
+    }
+    return data;
+  }
+  #updateCumulative() {
+    if (this.#cumulative.length > 0 && this.#cumulative[this.#cumulative.length - 1] === this.#processedWeight) {
+      return;
+    }
+    const n = this.#processed.length + 1;
+    if (this.#cumulative.length > n) {
+      this.#cumulative.length = n;
+    }
+    let prev = 0;
+    for (let i = 0; i < this.#processed.length; i++) {
+      const centroid = this.#processed[i];
+      const cur = centroid.weight;
+      this.#cumulative[i] = prev + cur / 2;
+      prev += cur;
+    }
+    this.#cumulative[this.#processed.length] = prev;
+  }
+  // Quantile returns the (approximate) quantile of
+  // the distribution. Accepted values for q are between 0 and 1.
+  // Returns NaN if Count is zero or bad inputs.
+  quantile(q) {
+    this.#process();
+    this.#updateCumulative();
+    if (q < 0 || q > 1 || this.#processed.length === 0) {
+      return NaN;
+    }
+    if (this.#processed.length === 1) {
+      return this.#processed[0].mean;
+    }
+    const index = q * this.#processedWeight;
+    if (index <= this.#processed[0].weight / 2) {
+      return this.#min + 2 * index / this.#processed[0].weight * (this.#processed[0].mean - this.#min);
+    }
+    const lower = binarySearch(
+      this.#cumulative.length,
+      (i) => -this.#cumulative[i] + index
+    );
+    if (lower + 1 !== this.#cumulative.length) {
+      const z12 = index - this.#cumulative[lower - 1];
+      const z22 = this.#cumulative[lower] - index;
+      return weightedAverage(
+        this.#processed[lower - 1].mean,
+        z22,
+        this.#processed[lower].mean,
+        z12
+      );
+    }
+    const z1 = index - this.#processedWeight - this.#processed[lower - 1].weight / 2;
+    const z2 = this.#processed[lower - 1].weight / 2 - z1;
+    return weightedAverage(
+      this.#processed[this.#processed.length - 1].mean,
+      z1,
+      this.#max,
+      z2
+    );
+  }
+  /**
+   * CDF returns the cumulative distribution function for a given value x.
+   */
+  cdf(x) {
+    this.#process();
+    this.#updateCumulative();
+    switch (this.#processed.length) {
+      case 0:
+        return 0;
+      case 1: {
+        const width = this.#max - this.#min;
+        if (x <= this.#min) {
+          return 0;
+        }
+        if (x >= this.#max) {
+          return 1;
+        }
+        if (x - this.#min <= width) {
+          return 0.5;
+        }
+        return (x - this.#min) / width;
+      }
+    }
+    if (x <= this.#min) {
+      return 0;
+    }
+    if (x >= this.#max) {
+      return 1;
+    }
+    const m0 = this.#processed[0].mean;
+    if (x <= m0) {
+      if (m0 - this.#min > 0) {
+        return (x - this.#min) / (m0 - this.#min) * this.#processed[0].weight / this.#processedWeight / 2;
+      }
+      return 0;
+    }
+    const mn = this.#processed[this.#processed.length - 1].mean;
+    if (x >= mn) {
+      if (this.#max - mn > 0) {
+        return 1 - (this.#max - x) / (this.#max - mn) * this.#processed[this.#processed.length - 1].weight / this.#processedWeight / 2;
+      }
+      return 1;
+    }
+    const upper = binarySearch(
+      this.#processed.length,
+      // Treat equals as greater than, so we can use the upper index
+      // This is equivalent to:
+      //   i => this.#processed[i].mean > x ? -1 : 1,
+      (i) => x - this.#processed[i].mean || 1
+    );
+    const z1 = x - this.#processed[upper - 1].mean;
+    const z2 = this.#processed[upper].mean - x;
+    return weightedAverage(
+      this.#cumulative[upper - 1],
+      z2,
+      this.#cumulative[upper],
+      z1
+    ) / this.#processedWeight;
+  }
+  #integratedQ(k) {
+    return (Math.sin(
+      Math.min(k, this.compression) * Math.PI / this.compression - Math.PI / 2
+    ) + 1) / 2;
+  }
+  #integratedLocation(q) {
+    return this.compression * (Math.asin(2 * q - 1) + Math.PI / 2) / Math.PI;
+  }
+};
+function weightedAverage(x1, w1, x2, w2) {
+  if (x1 <= x2) {
+    return weightedAverageSorted(x1, w1, x2, w2);
+  }
+  return weightedAverageSorted(x2, w2, x1, w1);
+}
+function weightedAverageSorted(x1, w1, x2, w2) {
+  const x = (x1 * w1 + x2 * w2) / (w1 + w2);
+  return Math.max(x1, Math.min(x, x2));
+}
+function processedSize(size, compression) {
+  if (size === 0) {
+    return Math.ceil(compression) * 2;
+  }
+  return size;
+}
+function unprocessedSize(size, compression) {
+  if (size === 0) {
+    return Math.ceil(compression) * 8;
+  }
+  return size;
+}
+
 // ../zero-schema/src/table-schema.ts
 function isOneHop(r) {
   return r.length === 1;
@@ -5704,8 +5887,8 @@ var negateOperatorMap = {
 function negateOperator(op) {
   return must(negateOperatorMap[op]);
 }
-function filterUndefined(array5) {
-  return array5.filter((e) => e !== void 0);
+function filterUndefined(array6) {
+  return array6.filter((e) => e !== void 0);
 }
 function filterTrue(conditions) {
   return conditions.filter((c) => !isAlwaysTrue(c));
@@ -5909,14 +6092,15 @@ function transformFilters(filters) {
 }
 
 // ../zql/src/builder/builder.ts
-function buildPipeline(ast, delegate) {
+function buildPipeline(ast, delegate, queryID) {
   return buildPipelineInternal(
     delegate.mapAst ? delegate.mapAst(ast) : ast,
     delegate,
+    queryID,
     ""
   );
 }
-function buildPipelineInternal(ast, delegate, name, partitionKey) {
+function buildPipelineInternal(ast, delegate, queryID, name, partitionKey) {
   const source = delegate.getSource(ast.table);
   if (!source) {
     throw new Error(`Source not found: ${ast.table}`);
@@ -5941,13 +6125,14 @@ function buildPipelineInternal(ast, delegate, name, partitionKey) {
     }
   }
   const conn = source.connect(must(ast.orderBy), ast.where, splitEditKeys);
-  let end = delegate.decorateInput(conn, `${name}:source(${ast.table})`);
+  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)`);
   }
   for (const csq of csqsFromCondition) {
-    end = applyCorrelatedSubQuery(csq, delegate, end, name, true);
+    end = applyCorrelatedSubQuery(csq, delegate, queryID, end, name, true);
   }
   if (ast.where && !fullyAppliedFilters) {
     end = applyWhere(end, ast.where, delegate, name);
@@ -5961,7 +6146,7 @@ function buildPipelineInternal(ast, delegate, name, partitionKey) {
   }
   if (ast.related) {
     for (const csq of ast.related) {
-      end = applyCorrelatedSubQuery(csq, delegate, end, name, false);
+      end = applyCorrelatedSubQuery(csq, delegate, queryID, end, name, false);
     }
   }
   return end;
@@ -6043,7 +6228,7 @@ function isNotAndDoesNotContainSubquery(condition) {
 function applySimpleCondition(input, condition) {
   return new Filter(input, createPredicate(condition));
 }
-function applyCorrelatedSubQuery(sq, delegate, end, name, fromCondition) {
+function applyCorrelatedSubQuery(sq, delegate, queryID, end, name, fromCondition) {
   if (sq.subquery.limit === 0 && fromCondition) {
     return end;
   }
@@ -6051,6 +6236,7 @@ function applyCorrelatedSubQuery(sq, delegate, end, name, fromCondition) {
   const child = buildPipelineInternal(
     sq.subquery,
     delegate,
+    queryID,
     `${name}.${sq.subquery.alias}`,
     sq.correlation.childField
   );
@@ -6795,7 +6981,6 @@ var QueryImpl = class _QueryImpl extends AbstractQuery {
       this._delegate,
       "materialize requires a query delegate to be set"
     );
-    const t0 = Date.now();
     let factory;
     if (typeof factoryOrTTL === "function") {
       factory = factoryOrTTL;
@@ -6803,27 +6988,33 @@ var QueryImpl = class _QueryImpl extends AbstractQuery {
       ttl = factoryOrTTL ?? DEFAULT_TTL_MS;
     }
     const ast = this._completeAst();
+    const queryID = this.customQueryID ? hashOfNameAndArgs(this.customQueryID.name, this.customQueryID.args) : this.hash();
     const queryCompleteResolver = resolver();
     let queryComplete = delegate.defaultQueryComplete;
+    const updateTTL = (newTTL) => {
+      this.customQueryID ? delegate.updateCustomQuery(this.customQueryID, newTTL) : delegate.updateServerQuery(ast, newTTL);
+    };
     const gotCallback = (got) => {
       if (got) {
-        const t1 = Date.now();
-        delegate.onQueryMaterialized(this.hash(), ast, t1 - t0);
+        delegate.addMetric(
+          "query-materialization-end-to-end",
+          performance.now() - t0,
+          queryID,
+          ast
+        );
         queryComplete = true;
         queryCompleteResolver.resolve(true);
       }
     };
-    const removeServerQuery = this.customQueryID ? delegate.addCustomQuery(this.customQueryID, ttl, gotCallback) : delegate.addServerQuery(ast, ttl, gotCallback);
-    const updateTTL = (newTTL) => {
-      this.customQueryID ? delegate.updateCustomQuery(this.customQueryID, newTTL) : delegate.updateServerQuery(ast, newTTL);
-    };
-    const input = buildPipeline(ast, delegate);
     let removeCommitObserver;
     const onDestroy = () => {
       input.destroy();
       removeCommitObserver?.();
-      removeServerQuery();
+      removeAddedQuery();
     };
+    const t0 = performance.now();
+    const removeAddedQuery = this.customQueryID ? delegate.addCustomQuery(this.customQueryID, ttl, gotCallback) : delegate.addServerQuery(ast, ttl, gotCallback);
+    const input = buildPipeline(ast, delegate, queryID);
     const view = delegate.batchViewUpdates(
       () => (factory ?? arrayViewFactory)(
         this,
@@ -6837,6 +7028,11 @@ var QueryImpl = class _QueryImpl extends AbstractQuery {
         updateTTL
       )
     );
+    delegate.addMetric(
+      "query-materialization-client",
+      performance.now() - t0,
+      queryID
+    );
     return view;
   }
   run(options) {
@@ -6930,23 +7126,12 @@ function isCompoundKey(field) {
 }
 
 export {
-  assert,
-  assertString,
-  assertNumber,
-  assertObject,
-  assertArray,
-  assertNotNull,
-  unreachable,
-  isProd,
-  hasOwn,
   deepEqual,
   assertJSONValue,
   assertJSONObject,
   stringCompare,
   compareCookies,
   assertCookie,
-  deepFreeze,
-  deepFreezeAllowUndefined,
   parse,
   test,
   readonly,
@@ -7037,11 +7222,15 @@ export {
   mapAST,
   mapCondition,
   h64,
+  mapValues,
+  mapEntries,
+  mapAllEntries,
   hashOfAST,
   hashOfNameAndArgs,
   compareValues,
   makeComparator,
   valuesEqual,
+  throwOutput,
   filterPush,
   ExpressionBuilder,
   createPredicate,
@@ -7060,6 +7249,8 @@ export {
   newQuerySymbol,
   AbstractQuery,
   inspectQueriesDownSchema,
+  inspectMetricsDownSchema,
+  inspectVersionDownSchema,
   inspectDownMessageSchema,
   primaryKeySchema,
   primaryKeyValueRecordSchema,
@@ -7072,6 +7263,7 @@ export {
   toGotQueriesKey,
   toMutationResponseKey,
   toPrimaryKeyString,
-  sourceNameFromKey
+  sourceNameFromKey,
+  TDigest
 };
-//# sourceMappingURL=chunk-LENWM5WE.js.map
+//# sourceMappingURL=chunk-O536GEIT.js.map