@minnowdb/core 0.7.10 → 0.8.0

package/dist/engine/live-aggregate.js

@@ -0,0 +1,226 @@
+import { childExpressions, hasAggregate, mapChildExpressions, executeRowQueryInternal, inferResultColumnDomains, externalizeQueryResult } from "./query.js";
+import { encodeQueryIdentity } from "./query-identity.js";
+import { exactNumericBinary, exactNumericValue, externalSqlDomainValue, isExactNumeric } from "./sql-domains.js";
+import { encodeSqlEqualityValue } from "./sql-semantics.js";
+class LiveAggregate {
+  inputPlan;
+  #outputPlan;
+  #aggregates;
+  #groupAliases;
+  #rows;
+  #groups;
+  #domains;
+  keyAlias;
+  #schema;
+  constructor(inputPlan, outputPlan, aggregates, groupAliases, keyAlias, rows = /* @__PURE__ */ new Map(), groups = /* @__PURE__ */ new Map(), domains = [], schema = []) {
+    this.inputPlan = inputPlan;
+    this.#outputPlan = outputPlan;
+    this.#aggregates = aggregates;
+    this.#groupAliases = groupAliases;
+    this.keyAlias = keyAlias;
+    this.#rows = rows;
+    this.#groups = groups;
+    this.#domains = domains;
+    this.#schema = schema;
+  }
+  static plan(plan, qualifiedKey) {
+    const aggregates = [];
+    const groupAliases = plan.groupBy.map((_, index) => `__minnow_live_group_${String(index)}`);
+    const groupKeys = new Map(plan.groupBy.map((expression, index) => [
+      encodeQueryIdentity(expression),
+      groupAliases[index] ?? ""
+    ]));
+    const rowLocal = (expression) => !hasAggregate(expression) && !["subquery", "exists", "window", "parameter", "wildcard"].includes(expression.kind) && childExpressions(expression).every(rowLocal);
+    if (!plan.groupBy.every(rowLocal))
+      return void 0;
+    const rewrite = (expression) => {
+      const grouped = groupKeys.get(encodeQueryIdentity(expression));
+      if (grouped !== void 0)
+        return { kind: "column", reference: grouped };
+      if (expression.kind === "call" && hasAggregate(expression)) {
+        if (!["COUNT", "SUM", "AVG"].includes(expression.name) || expression.arguments.length !== 1)
+          throw new TypeError("Not an additive live aggregate");
+        const argument = expression.arguments[0];
+        if (argument === void 0 || !(rowLocal(argument) || expression.name === "COUNT" && argument.kind === "wildcard"))
+          throw new TypeError("Not a row-local aggregate argument");
+        const alias = `__minnow_live_value_${String(aggregates.length)}`;
+        aggregates.push({
+          name: expression.name,
+          alias,
+          argument: argument.kind === "wildcard" ? { kind: "literal", value: 1 } : argument
+        });
+        return { kind: "column", reference: alias };
+      }
+      if (expression.kind === "column" || expression.kind === "window" || expression.kind === "subquery" || expression.kind === "exists")
+        throw new TypeError("Not a grouped live expression");
+      return mapChildExpressions(expression, rewrite);
+    };
+    try {
+      const select = plan.select.map((item) => ({ ...item, expression: rewrite(item.expression) }));
+      const having = plan.having.map((predicate) => ({
+        ...predicate,
+        left: rewrite(predicate.left),
+        right: rewrite(predicate.right)
+      }));
+      const outputAliases = new Set(select.map((item) => item.alias));
+      const orderBy = plan.orderBy.map((term) => ({
+        ...term,
+        expression: term.expression.kind === "column" && outputAliases.has(term.expression.reference) ? term.expression : rewrite(term.expression)
+      }));
+      if (aggregates.length === 0)
+        return void 0;
+      const keyAlias = "__minnow_live_aggregate_key";
+      const inputPlan = {
+        ...plan,
+        select: [
+          { alias: keyAlias, expression: { kind: "column", reference: qualifiedKey } },
+          ...plan.groupBy.map((expression, index) => ({
+            alias: groupAliases[index] ?? "",
+            expression
+          })),
+          ...aggregates.map(({ alias, argument }) => ({ alias, expression: argument }))
+        ],
+        groupBy: [],
+        having: [],
+        orderBy: []
+      };
+      delete inputPlan.limit;
+      delete inputPlan.offset;
+      const outputPlan = {
+        ...plan,
+        base: { table: "__minnow_live_groups", alias: "__minnow_live_groups" },
+        joins: [],
+        select,
+        predicates: having,
+        groupBy: [],
+        having: [],
+        orderBy
+      };
+      return new LiveAggregate(inputPlan, outputPlan, aggregates, groupAliases, keyAlias);
+    } catch {
+      return void 0;
+    }
+  }
+  patch(result, changed, token) {
+    const rows = new Map(this.#rows);
+    const groups = new Map(this.#groups);
+    const touched = /* @__PURE__ */ new Set();
+    const groupFor = (key, keys = []) => {
+      let group = groups.get(key);
+      if (group === void 0) {
+        group = {
+          keys,
+          members: 0,
+          counts: this.#aggregates.map(() => 0),
+          sums: this.#aggregates.map(() => exactNumericValue(0) ?? ""),
+          absolute: this.#aggregates.map(() => 0)
+        };
+        groups.set(key, group);
+        touched.add(key);
+      } else if (!touched.has(key)) {
+        group = {
+          ...group,
+          counts: [...group.counts],
+          sums: [...group.sums],
+          absolute: [...group.absolute]
+        };
+        groups.set(key, group);
+        touched.add(key);
+      }
+      return group;
+    };
+    const apply = (group, values, sign) => {
+      group.members += sign;
+      for (const [index, aggregate] of this.#aggregates.entries()) {
+        const value = values[index] ?? null;
+        if (value === null)
+          continue;
+        group.counts[index] = (group.counts[index] ?? 0) + sign;
+        if (aggregate.name !== "COUNT") {
+          if (typeof value !== "number" && !isExactNumeric(value))
+            throw new TypeError("Live SUM requires numeric values");
+          if (typeof value === "number") {
+            if (!Number.isSafeInteger(value))
+              throw new TypeError("Floating-point aggregates require full execution");
+            group.absolute[index] = (group.absolute[index] ?? 0) + sign * Math.abs(value);
+            if (!Number.isSafeInteger(group.absolute[index]))
+              throw new TypeError("Aggregate sum may round; requires full execution");
+          }
+          const sum = exactNumericBinary(sign === 1 ? "+" : "-", group.sums[index] ?? exactNumericValue(0), exactNumericValue(value));
+          if (sum === null || sum === void 0)
+            throw new TypeError("Invalid numeric aggregate contribution");
+          group.sums[index] = sum;
+        }
+      }
+    };
+    for (const key of changed) {
+      const old = rows.get(key);
+      if (old === void 0)
+        continue;
+      apply(groupFor(old.group), old.values, -1);
+      rows.delete(key);
+    }
+    for (const row of result.rows) {
+      const key = token(row[this.keyAlias] ?? null);
+      const keys = this.#groupAliases.map((alias) => row[alias] ?? null);
+      const group = JSON.stringify(keys.map(encodeSqlEqualityValue));
+      const values = this.#aggregates.map(({ alias }) => row[alias] ?? null);
+      apply(groupFor(group, keys), values, 1);
+      rows.set(key, { group, values });
+    }
+    if (this.#groupAliases.length === 0)
+      groupFor("[]");
+    else
+      for (const key of touched)
+        if (groups.get(key)?.members === 0)
+          groups.delete(key);
+    const domains = this.#aggregates.map(({ alias }, index) => result.columnDomains[result.columns.indexOf(alias)] ?? this.#domains[index] ?? null);
+    return new LiveAggregate(this.inputPlan, this.#outputPlan, this.#aggregates, this.#groupAliases, this.keyAlias, rows, groups, domains, result.columns.map((name, index) => {
+      const domain = result.columnDomains[index];
+      const value = result.rows.find((row) => row[name] !== null)?.[name];
+      const aggregate = this.#aggregates.find((item) => item.alias === name);
+      return {
+        name,
+        type: aggregate?.name === "COUNT" ? "number" : domain !== null && domain !== void 0 ? "string" : typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : value instanceof Date ? "datetime" : "string",
+        ...domain === null || domain === void 0 || aggregate?.name === "COUNT" ? {} : { sqlDomain: domain }
+      };
+    }));
+  }
+  result() {
+    const rows = [];
+    for (const group of this.#groups.values()) {
+      const row = {};
+      for (const [index, alias] of this.#groupAliases.entries())
+        row[alias] = group.keys[index] ?? null;
+      for (const [index, aggregate] of this.#aggregates.entries()) {
+        const count = group.counts[index] ?? 0;
+        const domain = this.#domains[index];
+        let value = aggregate.name === "COUNT" ? count : count === 0 ? null : group.sums[index] ?? null;
+        if (value !== null && aggregate.name !== "COUNT") {
+          if (domain?.kind !== "numeric") {
+            value = Number(externalSqlDomainValue(value));
+            if (aggregate.name === "AVG")
+              value /= count;
+          } else if (aggregate.name === "AVG")
+            value = exactNumericBinary("/", value, count, domain.scale) ?? null;
+        }
+        row[aggregate.alias] = value;
+      }
+      rows.push(row);
+    }
+    const result = executeRowQueryInternal(this.#outputPlan, /* @__PURE__ */ new Map([["__minnow_live_groups", rows]]));
+    result.columnDomains = inferResultColumnDomains(this.#outputPlan, /* @__PURE__ */ new Map([["__minnow_live_groups", this.#schema]]));
+    return externalizeQueryResult(result);
+  }
+  get retainedBytes() {
+    let bytes = 256 + encodeQueryIdentity(this.inputPlan).length * 2 + encodeQueryIdentity(this.#outputPlan).length * 2;
+    for (const [key, row] of this.#rows)
+      bytes += 64 + key.length * 2 + row.group.length * 2 + row.values.reduce((sum, value) => sum + (typeof value === "string" ? value.length * 2 + 16 : 16), 0);
+    for (const [key, group] of this.#groups)
+      bytes += 96 + key.length * 2 + group.sums.reduce((sum, value) => sum + value.length * 2 + 24, 0);
+    return bytes;
+  }
+}
+export {
+  LiveAggregate
+};

package/dist/engine/live-patch.d.ts

@@ -0,0 +1,21 @@
+import type { QueryResult, QueryRow } from "../plan/model.js";
+import type { LiveQueryDelivery } from "./live.js";
+export type LiveQueryPatch = {
+    readonly type: "reset";
+    readonly result: QueryResult;
+} | {
+    readonly type: "patch";
+    /** Each next position's previous position, or -1 for a changed/new row. */
+    readonly retained: Int32Array;
+    readonly changedRows: ReadonlyArray<{
+        readonly index: number;
+        readonly row: QueryRow;
+    }>;
+};
+export interface LiveQueryPatchOptions {
+    onPatch(patch: LiveQueryPatch, delivery: LiveQueryDelivery): void;
+    onError?(error: unknown): void;
+    onComplete?(): void;
+}
+/** Copy only changed payloads when provenance is available; resets establish a fresh baseline. */
+export declare function createLiveQueryPatch(result: QueryResult, delivery: LiveQueryDelivery): LiveQueryPatch;

package/dist/engine/live-patch.js

@@ -0,0 +1,31 @@
+import { copyDate } from "../date-value.js";
+function copyRow(row) {
+  const copy = { ...row };
+  for (const key of Object.keys(copy)) {
+    const value = copy[key];
+    if (value instanceof Date)
+      copy[key] = copyDate(value);
+  }
+  return copy;
+}
+function createLiveQueryPatch(result, delivery) {
+  if (delivery.retained === void 0 || delivery.initial)
+    return {
+      type: "reset",
+      result: {
+        columns: [...result.columns],
+        columnDomains: structuredClone(result.columnDomains),
+        rows: result.rows.map(copyRow)
+      }
+    };
+  const changedRows = [];
+  for (let index = 0; index < result.rows.length; index += 1) {
+    const row = result.rows[index];
+    if (row !== void 0 && (delivery.retained[index] ?? -1) < 0)
+      changedRows.push({ index, row: copyRow(row) });
+  }
+  return { type: "patch", retained: new Int32Array(delivery.retained), changedRows };
+}
+export {
+  createLiveQueryPatch
+};

package/dist/engine/live.d.ts

@@ -1,3 +1,5 @@
+import { type LiveQueryPatchOptions } from "./live-patch.js";
+export type { LiveQueryPatch, LiveQueryPatchOptions } from "./live-patch.js";
 import { type CatalogProbe, type Manifest, type StoragePage } from "../storage/types.js";
 import { type CompiledQuery, type QueryResult, type QueryValue } from "./query.js";
 /**
@@ -27,6 +29,8 @@ export interface LiveQuerySetOptions {
     readonly maxGroups?: number;
     /** Maximum result/observer subscriptions retained by this set. Defaults to 1,024. */
     readonly maxSubscriptions?: number;
+    /** Maximum modeled resident result and maintenance bytes per set. Defaults to 64 MiB. */
+    readonly maxRetainedBytes?: number;
     /**
      * Hand `onChange` the set's retained result instead of a private copy. The result is shared
      * with every equal subscription and with the next change comparison, so a subscriber must
@@ -64,6 +68,8 @@ export interface LiveQueryDelivery {
     readonly retained?: Int32Array;
 }
 export interface LiveQuerySubscribeOptions {
+    /** Borrow the read-only retained result for this subscription instead of copying it. */
+    readonly sharedResults?: boolean;
     onChange(result: QueryResult, delivery: LiveQueryDelivery): void;
     onError?(error: unknown): void;
     /** Called once when the subscription ends because the subscription or its set closed. */
@@ -114,6 +120,8 @@ export interface LiveQueryStats {
      * bounded by the engine at 64 rows and is not included.
      */
     retainedRows: number;
+    /** Modeled resident result and incremental maintenance bytes, counted once per group. */
+    retainedBytes: number;
     /** Work avoided because equal statements shared one query group or in-flight execution. */
     sharedExecutions: number;
     lastSweepMs: number;
@@ -146,6 +154,8 @@ export interface LiveQueryExecuteContext {
 export interface LiveMaintainedExecution {
     readonly result: QueryResult;
     readonly state: unknown;
+    /** Modeled total bytes retained by the result and opaque maintenance state. */
+    readonly retainedBytes?: number;
 }
 export interface LiveMaintainedChange extends LiveMaintainedExecution {
     readonly changed: boolean;
@@ -178,6 +188,8 @@ export declare class LiveQuerySet {
     get stats(): LiveQueryStats;
     /** Registers a query, delivers its current result, and shares work with equal statements. */
     subscribe(query: LiveQueryInput, options: LiveQuerySubscribeOptions): Promise<LiveQuerySubscription>;
+    /** Delivers resets or changed row payloads without constructing a private full row array per patch. */
+    subscribePatches(query: LiveQueryInput, options: LiveQueryPatchOptions): Promise<LiveQuerySubscription>;
     /** Observes invalidation; the statement executes inside the set only when asked to compare. */
     observe(query: LiveQueryInput, options: LiveQueryObserveOptions): Promise<LiveQuerySubscription>;
     /** Called by the owning database after each local write commit; also hints other tabs. */

package/dist/engine/live.js

@@ -1,3 +1,6 @@
+import { createLiveQueryPatch } from "./live-patch.js";
+import { queryResultRetainedBytes } from "./query-cache.js";
+import { encodeQueryIdentity } from "./query-identity.js";
 import { LiveQueryLimitError } from "./errors.js";
 const DEFAULT_LIVE_QUERY_MAX_GROUPS = 256;
 const DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS = 1024;
@@ -63,41 +66,6 @@ function cloneResult(result) {
     rows: result.rows.map((row) => cloneRow(row, columns))
   };
 }
-function encodeQueryIdentity(value, ancestors = /* @__PURE__ */ new Set()) {
-  if (value === null)
-    return "z";
-  if (typeof value === "undefined")
-    return "u";
-  if (typeof value === "boolean")
-    return value ? "b1" : "b0";
-  if (typeof value === "number") {
-    if (Number.isNaN(value))
-      return "nNaN;";
-    if (Object.is(value, -0))
-      return "n-0;";
-    return `n${String(value)};`;
-  }
-  if (typeof value === "string")
-    return `s${String(value.length)}:${value}`;
-  if (value instanceof Date)
-    return `d${String(dateMilliseconds(value))};`;
-  if (typeof value !== "object") {
-    throw new TypeError(`Unsupported live-query identity value: ${typeof value}`);
-  }
-  if (ancestors.has(value))
-    throw new TypeError("Live-query identity contains a cycle");
-  ancestors.add(value);
-  let encoded;
-  if (Array.isArray(value)) {
-    encoded = `a${String(value.length)}[${value.map((item) => encodeQueryIdentity(item, ancestors)).join("")}]`;
-  } else {
-    const record = value;
-    const keys = Object.keys(record).sort();
-    encoded = `o${String(keys.length)}{${keys.map((key) => `${encodeQueryIdentity(key, ancestors)}${encodeQueryIdentity(record[key], ancestors)}`).join("")}}`;
-  }
-  ancestors.delete(value);
-  return encoded;
-}
 function queryKey(query) {
   return encodeQueryIdentity(typeof query === "string" ? ["sql", query] : query.kind === "sql-query" ? ["sql-query", query.sql, query.params] : ["typed-query", query.plan]);
 }
@@ -141,6 +109,12 @@ function groupMemoizes(group) {
   }
   return false;
 }
+function callLiveCallback(callback) {
+  try {
+    callback?.();
+  } catch {
+  }
+}
 class LiveQuerySet {
   #host;
   #channel;
@@ -153,6 +127,7 @@ class LiveQuerySet {
   #lagging = /* @__PURE__ */ new Set();
   #maxGroups;
   #maxSubscriptions;
+  #maxRetainedBytes;
   #sharedResults;
   #incremental;
   #stats = {
@@ -167,6 +142,7 @@ class LiveQuerySet {
     maintained: 0,
     groupsVisited: 0,
     retainedRows: 0,
+    retainedBytes: 0,
     sharedExecutions: 0,
     lastSweepMs: 0
   };
@@ -187,6 +163,9 @@ class LiveQuerySet {
     }
     this.#maxGroups = boundedLiveLimit(options.maxGroups ?? DEFAULT_LIVE_QUERY_MAX_GROUPS, MAX_LIVE_QUERY_GROUPS, "group");
     this.#maxSubscriptions = boundedLiveLimit(options.maxSubscriptions ?? DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS, MAX_LIVE_QUERY_SUBSCRIPTIONS, "subscription");
+    this.#maxRetainedBytes = options.maxRetainedBytes ?? 64 * 1024 * 1024;
+    if (!Number.isSafeInteger(this.#maxRetainedBytes) || this.#maxRetainedBytes < 0)
+      throw new RangeError("Live query retained byte limit must be a non-negative safe integer");
     this.#sharedResults = options.sharedResults === true;
     this.#incremental = options.incremental !== false;
     this.#host = host;
@@ -212,7 +191,10 @@ class LiveQuerySet {
     let retainedRows = 0;
     for (const group of this.#groups.values())
       retainedRows += group.result?.rows.length ?? 0;
-    return { ...this.#stats, retainedRows };
+    let retainedBytes = 0;
+    for (const group of this.#groups.values())
+      retainedBytes += group.retainedBytes;
+    return { ...this.#stats, retainedRows, retainedBytes };
   }
   #freshProbe() {
     let pending = this.#pendingProbe;
@@ -274,6 +256,14 @@ class LiveQuerySet {
     }
     return this.#subscriptionHandle(group, subscriber);
   }
+  subscribePatches(query, options) {
+    return this.subscribe(query, {
+      sharedResults: true,
+      onChange: (result, delivery) => options.onPatch(createLiveQueryPatch(result, delivery), delivery),
+      ...options.onError === void 0 ? {} : { onError: options.onError.bind(options) },
+      ...options.onComplete === void 0 ? {} : { onComplete: options.onComplete.bind(options) }
+    });
+  }
   async observe(query, options) {
     this.#throwIfClosed();
     this.#reserveSubscription();
@@ -338,7 +328,7 @@ class LiveQuerySet {
     this.#subscriptionCount -= 1;
     group.subscribers.delete(subscriber);
     if (complete)
-      subscriber.options.onComplete?.();
+      callLiveCallback(() => subscriber.options.onComplete?.());
     this.#removeEmptyGroup(group);
   }
   #removeEmptyGroup(group) {
@@ -382,6 +372,7 @@ class LiveQuerySet {
       subscribers: /* @__PURE__ */ new Set(),
       seenProbe: after,
       result: void 0,
+      retainedBytes: 0,
       execution: void 0,
       deliveries: 0,
       maintenance: void 0,
@@ -445,6 +436,7 @@ class LiveQuerySet {
       await this.#acquireExecutionSlot();
       let executed;
       let maintenance;
+      let retainedBytes;
       try {
         if (this.#incremental && this.#host.executeMaintainable !== void 0 && !group.unmaintainable) {
           const maintained = await this.#host.executeMaintainable(group.query, context);
@@ -453,6 +445,7 @@ class LiveQuerySet {
           else {
             executed = maintained.result;
             maintenance = maintained.state;
+            retainedBytes = maintained.retainedBytes;
           }
         }
         executed ??= await this.#host.execute(group.query, context);
@@ -461,8 +454,7 @@ class LiveQuerySet {
       }
       const previous = group.result;
       const changed = previous === void 0 || !sameResult(previous, executed);
-      group.result = executed;
-      group.maintenance = maintenance;
+      this.#retain(group, executed, maintenance, retainedBytes);
       return { result: executed, changed };
     })();
     group.execution = execution;
@@ -473,6 +465,18 @@ class LiveQuerySet {
         group.execution = void 0;
     }
   }
+  #retain(group, result, state, hint) {
+    const bytes = Math.max(queryResultRetainedBytes(result) + result.rows.length * 48, hint ?? (state === group.maintenance ? group.retainedBytes : 0));
+    let total = bytes;
+    for (const other of this.#groups.values())
+      if (other !== group)
+        total += other.retainedBytes;
+    if (!Number.isSafeInteger(total) || total > this.#maxRetainedBytes)
+      throw new LiveQueryLimitError("byte", this.#maxRetainedBytes);
+    group.result = result;
+    group.maintenance = state;
+    group.retainedBytes = bytes;
+  }
   async #acquireExecutionSlot() {
     if (this.#executing < LIVE_QUERY_EXECUTION_CONCURRENCY) {
       this.#executing += 1;
@@ -509,8 +513,7 @@ class LiveQuerySet {
         verdict.declined = true;
         return { result: retained, changed: false };
       }
-      group.result = maintained.result;
-      group.maintenance = maintained.state;
+      this.#retain(group, maintained.result, maintained.state, maintained.retainedBytes);
       return {
         result: maintained.result,
         changed: maintained.changed,
@@ -531,7 +534,7 @@ class LiveQuerySet {
       return;
     subscriber.delivered = true;
     const consecutive = subscriber.seenDelivery === group.deliveries - 1;
-    subscriber.options.onChange(this.#sharedResults ? result : cloneResult(result), retained !== void 0 && consecutive && !delivery.initial ? { ...delivery, retained } : delivery);
+    subscriber.options.onChange(this.#sharedResults || subscriber.options.sharedResults === true ? result : cloneResult(result), retained !== void 0 && consecutive && !delivery.initial ? { ...delivery, retained } : delivery);
     subscriber.seenDelivery = group.deliveries;
   }
   #deliverInvalidation(subscriber, invalidation) {
@@ -569,10 +572,10 @@ class LiveQuerySet {
           continue;
         subscriber.closed = true;
         this.#subscriptionCount -= 1;
-        subscriber.options.onComplete?.();
+        callLiveCallback(() => subscriber.options.onComplete?.());
       }
     }
-    this.#onClosed?.();
+    callLiveCallback(this.#onClosed);
   }
   #hint() {
     if (this.#closed)
@@ -735,23 +738,23 @@ class LiveQuerySet {
         if (isObserver(subscriber)) {
           if (execution !== void 0 && !execution.changed && subscriber.options.suppressUnchanged === true) {
             this.#stats.notificationsSuppressed += 1;
-            return;
+            continue;
           }
           try {
             this.#deliverInvalidation(subscriber, invalidation);
             this.#stats.invalidations += 1;
           } catch (error) {
-            subscriber.options.onError?.(error);
+            callLiveCallback(() => subscriber.options.onError?.(error));
           }
         } else if (isResultSubscriber(subscriber) && execution !== void 0) {
           if (!execution.changed) {
             this.#stats.notificationsSuppressed += 1;
-            return;
+            continue;
           }
           try {
             this.#deliverResult(group, subscriber, execution.result, invalidation, execution.retained);
           } catch (error) {
-            subscriber.options.onError?.(error);
+            callLiveCallback(() => subscriber.options.onError?.(error));
           }
         }
       }
@@ -769,7 +772,7 @@ class LiveQuerySet {
     for (const subscriber of group.subscribers) {
       if (subscriber.closed)
         continue;
-      subscriber.options.onError?.(error);
+      callLiveCallback(() => subscriber.options.onError?.(error));
     }
   }
   async #changedTablesSince(after, until) {

package/dist/engine/optimizer.js

@@ -1,3 +1,4 @@
+import { encodeQueryIdentity } from "./query-identity.js";
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { crossJoinPlan } from "../plan/model.js";
 import { blockHasRowWindow, blockHasSubqueries, childExpressions, DUAL_TABLE, expressionAliases, forEachBlockExpression, forEachNestedBlock, hasAggregate, isAggregateCall, isScalarFunctionName, mapBlockExpressions, mapChildExpressions, parseQuantified, scalarFunctionNames, scalarFunctionValue, splitCondition, statementDatetimeNames, volatileScalarFunctionNames, transparentProjectionSource, dateTruncValue, integerQuotient } from "./query.js";
@@ -557,7 +558,7 @@ function propagateJoinKeyConstants(block) {
   }
   if (pairs.length === 0)
     return;
-  const signature = (predicate) => JSON.stringify(predicate);
+  const signature = (predicate) => encodeQueryIdentity(predicate);
   const present = new Set(block.predicates.map(signature));
   const implied = [];
   const constantSide = (predicate) => {
@@ -785,9 +786,9 @@ function decorrelateBlock(block, nextAlias) {
     if (!expressionHasCorrelatedSubquery(item.expression))
       continue;
     if (grouped) {
-      const groupedExpressions = new Set(block.groupBy.map((group) => JSON.stringify(group)));
+      const groupedExpressions = new Set(block.groupBy.map((group) => encodeQueryIdentity(group)));
       const outerReferences = correlatedOuterReferences(item.expression);
-      if (containsAggregateCall(item.expression) || outerReferences.some((reference) => !groupedExpressions.has(JSON.stringify({ kind: "column", reference })))) {
+      if (containsAggregateCall(item.expression) || outerReferences.some((reference) => !groupedExpressions.has(encodeQueryIdentity({ kind: "column", reference })))) {
         throw new TypeError("A grouped correlated select-list subquery must reference only GROUP BY columns and cannot be nested inside an aggregate");
       }
     }
@@ -2428,7 +2429,11 @@ function foldExpression(expression) {
         if (folded === null || typeof folded === "string" || typeof folded === "boolean" || folded instanceof Date || typeof folded === "number" && Number.isFinite(folded)) {
           const target = foldedArguments[1];
           const targetWord = expression.name === "CAST" && target?.kind === "literal" && typeof target.value === "string" ? target.value : void 0;
-          const sqlDomain = targetWord?.startsWith("numeric:") === true ? (() => {
+          const first = literalValues[0];
+          const sqlDomain = expression.name === "ARRAY" ? {
+            kind: "array",
+            element: typeof first === "number" ? "DOUBLE" : typeof first === "boolean" ? "BOOLEAN" : first instanceof Date ? "TIMESTAMP" : "TEXT"
+          } : targetWord?.startsWith("numeric:") === true ? (() => {
             const [, precisionWord = "", scaleWord = ""] = targetWord.split(":");
             return {
               kind: "numeric",
@@ -2565,8 +2570,8 @@ function rewriteForInner(expression, source, derived, singleSource) {
     if (containsAggregateOrWindow(item.expression))
       return void 0;
     if (derived.groupBy.length > 0) {
-      const signature = JSON.stringify(item.expression);
-      if (!derived.groupBy.some((group) => JSON.stringify(group) === signature)) {
+      const signature = encodeQueryIdentity(item.expression);
+      if (!derived.groupBy.some((group) => encodeQueryIdentity(group) === signature)) {
         return void 0;
       }
     }

package/dist/engine/query-cache.js

@@ -1,3 +1,4 @@
+import { encodeQueryIdentity } from "./query-identity.js";
 import { copyDate, dateMilliseconds } from "../date-value.js";
 import { estimateValuesBytes } from "./byte-estimates.js";
 import { copyQueryResultExternalization } from "./query.js";
@@ -7,19 +8,7 @@ function queryResultMemoKey(sql, params) {
   return JSON.stringify([sql, params.map(encodeParameter)]);
 }
 function planMemoKey(plan) {
-  return JSON.stringify(plan, (_key, value) => {
-    if (value instanceof Date)
-      return { $date: dateMilliseconds(value) };
-    if (typeof value === "bigint")
-      return { $bigint: value.toString() };
-    if (typeof value === "number") {
-      if (Object.is(value, -0))
-        return { $number: "-0" };
-      if (!Number.isFinite(value))
-        return { $number: String(value) };
-    }
-    return value;
-  });
+  return encodeQueryIdentity(plan);
 }
 function copyQueryResult(result) {
   const columns = result.columns;

package/dist/engine/query-generations.d.ts

@@ -0,0 +1,8 @@
+import type { Manifest, StoragePage } from "../storage/types.js";
+/** Bounded, process-local table generations proved by a contiguous durable commit history. */
+export declare class QueryGenerations {
+    #private;
+    readonly page: (after: number | null, limit: number) => Promise<StoragePage<Manifest, number>>;
+    constructor(page: (after: number | null, limit: number) => Promise<StoragePage<Manifest, number>>);
+    key(tableIds: readonly string[], version: number | null): Promise<string>;
+}