@minnowdb/core 0.7.0 → 0.7.1

package/dist/engine/live.js

@@ -1,690 +1,646 @@
 import { LiveQueryLimitError } from "./errors.js";
-export const DEFAULT_LIVE_QUERY_MAX_GROUPS = 256;
-export const DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS = 1_024;
-export const MAX_LIVE_QUERY_GROUPS = 4_096;
-export const MAX_LIVE_QUERY_SUBSCRIPTIONS = 16_384;
-export const MAX_LIVE_QUERY_SETS_PER_DATABASE = 256;
-export { LiveQueryLimitError } from "./errors.js";
+const DEFAULT_LIVE_QUERY_MAX_GROUPS = 256;
+const DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS = 1024;
+const MAX_LIVE_QUERY_GROUPS = 4096;
+const MAX_LIVE_QUERY_SUBSCRIPTIONS = 16384;
+const MAX_LIVE_QUERY_SETS_PER_DATABASE = 256;
+import { LiveQueryLimitError as LiveQueryLimitError2 } from "./errors.js";
 const digestScratch = new DataView(new ArrayBuffer(8));
-/** Fast inequality filter. Equal digests are always followed by exact comparison. */
 function digestResult(result) {
-    let hash = 0x811c9dc5;
-    const mixByte = (byte) => {
-        hash = Math.imul(hash ^ byte, 0x01000193) >>> 0;
-    };
-    const mixNumber = (value) => {
-        digestScratch.setFloat64(0, value);
-        for (let index = 0; index < 8; index += 1)
-            mixByte(digestScratch.getUint8(index));
-    };
-    const mixString = (value) => {
-        for (let index = 0; index < value.length; index += 1) {
-            const code = value.charCodeAt(index);
-            mixByte(code & 0xff);
-            mixByte(code >>> 8);
-        }
-        mixByte(0xff);
-    };
-    for (const column of result.columns)
-        mixString(column);
-    for (const domain of result.columnDomains)
-        mixString(JSON.stringify(domain));
-    for (const row of result.rows) {
-        for (const column of result.columns) {
-            const value = row[column] ?? null;
-            if (value === null)
-                mixByte(1);
-            else if (typeof value === "number") {
-                mixByte(2);
-                mixNumber(value);
-            }
-            else if (typeof value === "string") {
-                mixByte(3);
-                mixString(value);
-            }
-            else if (typeof value === "boolean")
-                mixByte(value ? 4 : 5);
-            else {
-                mixByte(6);
-                mixNumber(dateMilliseconds(value));
-            }
-        }
-        mixByte(0xfe);
-    }
-    return hash;
+  let hash = 2166136261;
+  const mixByte = (byte) => {
+    hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+  };
+  const mixNumber = (value) => {
+    digestScratch.setFloat64(0, value);
+    for (let index = 0; index < 8; index += 1)
+      mixByte(digestScratch.getUint8(index));
+  };
+  const mixString = (value) => {
+    for (let index = 0; index < value.length; index += 1) {
+      const code = value.charCodeAt(index);
+      mixByte(code & 255);
+      mixByte(code >>> 8);
+    }
+    mixByte(255);
+  };
+  for (const column of result.columns)
+    mixString(column);
+  for (const domain of result.columnDomains)
+    mixString(JSON.stringify(domain));
+  for (const row of result.rows) {
+    for (const column of result.columns) {
+      const value = row[column] ?? null;
+      if (value === null)
+        mixByte(1);
+      else if (typeof value === "number") {
+        mixByte(2);
+        mixNumber(value);
+      } else if (typeof value === "string") {
+        mixByte(3);
+        mixString(value);
+      } else if (typeof value === "boolean")
+        mixByte(value ? 4 : 5);
+      else {
+        mixByte(6);
+        mixNumber(dateMilliseconds(value));
+      }
+    }
+    mixByte(254);
+  }
+  return hash;
 }
 function sameQueryValue(left, right) {
-    if (left instanceof Date || right instanceof Date) {
-        return (left instanceof Date &&
-            right instanceof Date &&
-            Object.is(dateMilliseconds(left), dateMilliseconds(right)));
-    }
-    return Object.is(left, right);
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && Object.is(dateMilliseconds(left), dateMilliseconds(right));
+  }
+  return Object.is(left, right);
 }
 function sameResult(left, right) {
-    if (left.columns.length !== right.columns.length || left.rows.length !== right.rows.length) {
+  if (left.columns.length !== right.columns.length || left.rows.length !== right.rows.length) {
+    return false;
+  }
+  for (let index = 0; index < left.columns.length; index += 1) {
+    if (left.columns[index] !== right.columns[index])
+      return false;
+    if (JSON.stringify(left.columnDomains[index]) !== JSON.stringify(right.columnDomains[index])) {
+      return false;
+    }
+  }
+  for (let rowIndex = 0; rowIndex < left.rows.length; rowIndex += 1) {
+    const leftRow = left.rows[rowIndex];
+    const rightRow = right.rows[rowIndex];
+    if (leftRow === void 0 || rightRow === void 0)
+      return false;
+    for (const column of left.columns) {
+      if (!sameQueryValue(leftRow[column] ?? null, rightRow[column] ?? null))
         return false;
     }
-    for (let index = 0; index < left.columns.length; index += 1) {
-        if (left.columns[index] !== right.columns[index])
-            return false;
-        if (JSON.stringify(left.columnDomains[index]) !== JSON.stringify(right.columnDomains[index])) {
-            return false;
-        }
-    }
-    for (let rowIndex = 0; rowIndex < left.rows.length; rowIndex += 1) {
-        const leftRow = left.rows[rowIndex];
-        const rightRow = right.rows[rowIndex];
-        if (leftRow === undefined || rightRow === undefined)
-            return false;
-        for (const column of left.columns) {
-            if (!sameQueryValue(leftRow[column] ?? null, rightRow[column] ?? null))
-                return false;
-        }
-    }
-    return true;
+  }
+  return true;
 }
 function cloneRow(row, columns) {
-    const cloned = {};
-    for (const column of columns) {
-        const value = row[column] ?? null;
-        const copy = value instanceof Date ? copyDate(value) : value;
-        if (column === "__proto__") {
-            Object.defineProperty(cloned, column, {
-                value: copy,
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-        else
-            cloned[column] = copy;
-    }
-    return cloned;
+  const cloned = {};
+  for (const column of columns) {
+    const value = row[column] ?? null;
+    const copy = value instanceof Date ? copyDate(value) : value;
+    if (column === "__proto__") {
+      Object.defineProperty(cloned, column, {
+        value: copy,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else
+      cloned[column] = copy;
+  }
+  return cloned;
 }
 function cloneResult(result) {
-    const columns = [...result.columns];
-    return {
-        columns,
-        columnDomains: structuredClone(result.columnDomains),
-        rows: result.rows.map((row) => cloneRow(row, columns)),
-    };
+  const columns = [...result.columns];
+  return {
+    columns,
+    columnDomains: structuredClone(result.columnDomains),
+    rows: result.rows.map((row) => cloneRow(row, columns))
+  };
 }
-/** Type-tagged, length-delimited structural identity. Unlike JSON, it preserves Date vs string,
- * -0, non-finite numbers, and undefined fields, so deduplication cannot merge distinct plans. */
-function encodeQueryIdentity(value, ancestors = 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 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]);
+  return encodeQueryIdentity(typeof query === "string" ? ["sql", query] : query.kind === "sql-query" ? ["sql-query", query.sql, query.params] : ["typed-query", query.plan]);
 }
 function sameProbe(left, right) {
-    return left.manifestVersion === right.manifestVersion && left.schemaEpoch === right.schemaEpoch;
+  return left.manifestVersion === right.manifestVersion && left.schemaEpoch === right.schemaEpoch;
 }
 function versionOrdinal(version) {
-    return version ?? -1;
+  return version ?? -1;
 }
 function boundedLiveLimit(value, maximum, label) {
-    if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
-        throw new RangeError(`Live query ${label} limit must be between 1 and ${String(maximum)}`);
-    }
-    return value;
+  if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    throw new RangeError(`Live query ${label} limit must be between 1 and ${String(maximum)}`);
+  }
+  return value;
 }
-/** Structural changes have their own counter so ordinary commits and physical-index state churn
- * do not force dependency resolution. A manifest reset is still widened: it can only result from
- * replacing or rebuilding the durable database state. */
 function catalogChangedBetween(previous, current) {
-    return (versionOrdinal(current.manifestVersion) < versionOrdinal(previous.manifestVersion) ||
-        current.schemaEpoch !== previous.schemaEpoch);
+  return versionOrdinal(current.manifestVersion) < versionOrdinal(previous.manifestVersion) || current.schemaEpoch !== previous.schemaEpoch;
 }
-export class LiveQuerySet {
-    #host;
-    #channel;
-    #channelListener = () => {
+class LiveQuerySet {
+  #host;
+  #channel;
+  #channelListener = () => {
+    this.#hint();
+  };
+  #groups = /* @__PURE__ */ new Map();
+  #opening = /* @__PURE__ */ new Map();
+  #groupsByTable = /* @__PURE__ */ new Map();
+  #maxGroups;
+  #maxSubscriptions;
+  #stats = {
+    hints: 0,
+    versionChecks: 0,
+    sweeps: 0,
+    reruns: 0,
+    rerunsAvoided: 0,
+    zoneSkips: 0,
+    notificationsSuppressed: 0,
+    invalidations: 0,
+    sharedExecutions: 0,
+    lastSweepMs: 0
+  };
+  #lastProbe;
+  #sweepChain = Promise.resolve();
+  #sweepQueued = false;
+  #pollTimer;
+  #closed = false;
+  #subscriptionCount = 0;
+  #ownsChannel;
+  #onClosed;
+  constructor(host, options = {}) {
+    if (options.pollIntervalMs !== void 0 && (!Number.isSafeInteger(options.pollIntervalMs) || options.pollIntervalMs <= 0)) {
+      throw new RangeError("Live query poll interval must be a positive whole number");
+    }
+    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.#host = host;
+    if (options.channel !== void 0) {
+      this.#channel = options.channel;
+      this.#ownsChannel = false;
+    } else if (options.channelName !== void 0 && typeof BroadcastChannel !== "undefined") {
+      this.#channel = new BroadcastChannel(options.channelName);
+      this.#ownsChannel = true;
+    } else {
+      this.#channel = void 0;
+      this.#ownsChannel = false;
+    }
+    this.#onClosed = options.onClosed;
+    this.#channel?.addEventListener("message", this.#channelListener);
+    if (options.pollIntervalMs !== void 0) {
+      this.#pollTimer = setInterval(() => {
         this.#hint();
+      }, options.pollIntervalMs);
+    }
+  }
+  get stats() {
+    return { ...this.#stats };
+  }
+  #throwIfClosed() {
+    if (this.#closed)
+      throw new Error("Live query set is closed");
+  }
+  #reserveSubscription() {
+    if (this.#subscriptionCount >= this.#maxSubscriptions) {
+      throw new LiveQueryLimitError("subscription", this.#maxSubscriptions);
+    }
+    this.#subscriptionCount += 1;
+  }
+  async subscribe(query, options) {
+    this.#throwIfClosed();
+    this.#reserveSubscription();
+    let group;
+    let subscriber;
+    try {
+      group = await this.#getOrOpenGroup(query);
+      this.#throwIfClosed();
+      subscriber = {
+        kind: "result",
+        options,
+        delivered: false,
+        closed: false
+      };
+      group.subscribers.add(subscriber);
+      await this.refresh();
+      this.#throwIfClosed();
+      if (!subscriber.delivered) {
+        const result = group.result ?? (await this.#executeGroup(group)).result;
+        this.#throwIfClosed();
+        if (!subscriber.closed)
+          this.#deliverResult(subscriber, result);
+      }
+    } catch (error) {
+      if (group !== void 0 && subscriber !== void 0) {
+        this.#removeSubscriber(group, subscriber, false);
+      } else {
+        this.#subscriptionCount -= 1;
+        if (group !== void 0)
+          this.#removeEmptyGroup(group);
+      }
+      throw error;
+    }
+    return this.#subscriptionHandle(group, subscriber);
+  }
+  async observe(query, options) {
+    this.#throwIfClosed();
+    this.#reserveSubscription();
+    let group;
+    let subscriber;
+    try {
+      group = await this.#getOrOpenGroup(query);
+      this.#throwIfClosed();
+      subscriber = {
+        kind: "observer",
+        options,
+        delivered: false,
+        closed: false
+      };
+      group.subscribers.add(subscriber);
+      await this.refresh();
+      this.#throwIfClosed();
+      if (!subscriber.delivered) {
+        this.#deliverInvalidation(subscriber, { ...group.seenProbe, initial: true });
+      }
+    } catch (error) {
+      if (group !== void 0 && subscriber !== void 0) {
+        this.#removeSubscriber(group, subscriber, false);
+      } else {
+        this.#subscriptionCount -= 1;
+        if (group !== void 0)
+          this.#removeEmptyGroup(group);
+      }
+      throw error;
+    }
+    return this.#subscriptionHandle(group, subscriber);
+  }
+  #subscriptionHandle(group, subscriber) {
+    return {
+      dependencyTableIds: [...group.dependencies],
+      close: () => {
+        this.#removeSubscriber(group, subscriber, true);
+      }
     };
-    #groups = new Map();
-    #opening = new Map();
-    #groupsByTable = new Map();
-    #maxGroups;
-    #maxSubscriptions;
-    #stats = {
-        hints: 0,
-        versionChecks: 0,
-        sweeps: 0,
-        reruns: 0,
-        rerunsAvoided: 0,
-        zoneSkips: 0,
-        notificationsSuppressed: 0,
-        invalidations: 0,
-        sharedExecutions: 0,
-        lastSweepMs: 0,
+  }
+  #removeSubscriber(group, subscriber, complete) {
+    if (subscriber.closed)
+      return;
+    subscriber.closed = true;
+    this.#subscriptionCount -= 1;
+    group.subscribers.delete(subscriber);
+    if (complete)
+      subscriber.options.onComplete?.();
+    this.#removeEmptyGroup(group);
+  }
+  #removeEmptyGroup(group) {
+    if (group.subscribers.size !== 0)
+      return;
+    if (this.#groups.get(group.key) !== group)
+      return;
+    this.#groups.delete(group.key);
+    this.#unindexGroup(group, group.dependencies);
+  }
+  async #getOrOpenGroup(query) {
+    const key = queryKey(query);
+    const existing = this.#groups.get(key);
+    if (existing !== void 0) {
+      this.#stats.sharedExecutions += 1;
+      return existing;
+    }
+    const opening = this.#opening.get(key);
+    if (opening !== void 0) {
+      this.#stats.sharedExecutions += 1;
+      return opening;
+    }
+    if (this.#groups.size + this.#opening.size >= this.#maxGroups) {
+      throw new LiveQueryLimitError("group", this.#maxGroups);
+    }
+    const created = this.#openGroup(key, query);
+    this.#opening.set(key, created);
+    try {
+      return await created;
+    } finally {
+      this.#opening.delete(key);
+    }
+  }
+  async #openGroup(key, query) {
+    const { dependencies, probe: after } = await this.#stableDependencies(query);
+    const group = {
+      key,
+      query,
+      dependencies,
+      subscribers: /* @__PURE__ */ new Set(),
+      seenProbe: after,
+      result: void 0,
+      digest: void 0,
+      execution: void 0
     };
-    #lastProbe;
-    #sweepChain = Promise.resolve();
-    #sweepQueued = false;
-    #pollTimer;
-    #closed = false;
-    #subscriptionCount = 0;
-    #ownsChannel;
-    #onClosed;
-    constructor(host, options = {}) {
-        if (options.pollIntervalMs !== undefined &&
-            (!Number.isSafeInteger(options.pollIntervalMs) || options.pollIntervalMs <= 0)) {
-            throw new RangeError("Live query poll interval must be a positive whole number");
-        }
-        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.#host = host;
-        if (options.channel !== undefined) {
-            this.#channel = options.channel;
-            this.#ownsChannel = false;
-        }
-        else if (options.channelName !== undefined && typeof BroadcastChannel !== "undefined") {
-            this.#channel = new BroadcastChannel(options.channelName);
-            this.#ownsChannel = true;
-        }
-        else {
-            this.#channel = undefined;
-            this.#ownsChannel = false;
-        }
-        this.#onClosed = options.onClosed;
-        this.#channel?.addEventListener("message", this.#channelListener);
-        if (options.pollIntervalMs !== undefined) {
-            this.#pollTimer = setInterval(() => {
-                this.#hint();
-            }, options.pollIntervalMs);
-        }
-    }
-    get stats() {
-        return { ...this.#stats };
-    }
-    #throwIfClosed() {
-        if (this.#closed)
-            throw new Error("Live query set is closed");
-    }
-    #reserveSubscription() {
-        if (this.#subscriptionCount >= this.#maxSubscriptions) {
-            throw new LiveQueryLimitError("subscription", this.#maxSubscriptions);
-        }
-        this.#subscriptionCount += 1;
-    }
-    /** Registers a query, delivers its current result, and shares work with equal statements. */
-    async subscribe(query, options) {
-        this.#throwIfClosed();
-        this.#reserveSubscription();
-        let group;
-        let subscriber;
-        try {
-            group = await this.#getOrOpenGroup(query);
-            this.#throwIfClosed();
-            subscriber = {
-                kind: "result",
-                options,
-                delivered: false,
-                closed: false,
-            };
-            group.subscribers.add(subscriber);
-            // Reconcile before exposing a shared cached result to a late subscriber.
-            await this.refresh();
-            this.#throwIfClosed();
-            if (!subscriber.delivered) {
-                const result = group.result ?? (await this.#executeGroup(group)).result;
-                this.#throwIfClosed();
-                if (!subscriber.closed)
-                    this.#deliverResult(subscriber, result);
-            }
-        }
-        catch (error) {
-            if (group !== undefined && subscriber !== undefined) {
-                this.#removeSubscriber(group, subscriber, false);
-            }
-            else {
-                this.#subscriptionCount -= 1;
-                if (group !== undefined)
-                    this.#removeEmptyGroup(group);
-            }
-            throw error;
-        }
-        return this.#subscriptionHandle(group, subscriber);
-    }
-    /** Observes invalidation without executing the statement inside the set. */
-    async observe(query, options) {
-        this.#throwIfClosed();
-        this.#reserveSubscription();
-        let group;
-        let subscriber;
-        try {
-            group = await this.#getOrOpenGroup(query);
-            this.#throwIfClosed();
-            subscriber = {
-                kind: "observer",
-                options,
-                delivered: false,
-                closed: false,
-            };
-            group.subscribers.add(subscriber);
-            await this.refresh();
-            this.#throwIfClosed();
-            if (!subscriber.delivered) {
-                this.#deliverInvalidation(subscriber, { ...group.seenProbe, initial: true });
-            }
-        }
-        catch (error) {
-            if (group !== undefined && subscriber !== undefined) {
-                this.#removeSubscriber(group, subscriber, false);
-            }
-            else {
-                this.#subscriptionCount -= 1;
-                if (group !== undefined)
-                    this.#removeEmptyGroup(group);
-            }
-            throw error;
-        }
-        return this.#subscriptionHandle(group, subscriber);
-    }
-    #subscriptionHandle(group, subscriber) {
-        return {
-            dependencyTableIds: [...group.dependencies],
-            close: () => {
-                this.#removeSubscriber(group, subscriber, true);
-            },
-        };
-    }
-    #removeSubscriber(group, subscriber, complete) {
+    this.#groups.set(key, group);
+    this.#indexGroup(group, dependencies);
+    if (this.#lastProbe === void 0 || versionOrdinal(after.manifestVersion) < versionOrdinal(this.#lastProbe.manifestVersion)) {
+      this.#lastProbe = after;
+    }
+    return group;
+  }
+  #indexGroup(group, dependencies) {
+    for (const tableId of dependencies) {
+      let groups = this.#groupsByTable.get(tableId);
+      if (groups === void 0) {
+        groups = /* @__PURE__ */ new Set();
+        this.#groupsByTable.set(tableId, groups);
+      }
+      groups.add(group);
+    }
+  }
+  #unindexGroup(group, dependencies) {
+    for (const tableId of dependencies) {
+      const groups = this.#groupsByTable.get(tableId);
+      groups?.delete(group);
+      if (groups?.size === 0)
+        this.#groupsByTable.delete(tableId);
+    }
+  }
+  async #refreshDependencies(group) {
+    const { dependencies: next } = await this.#stableDependencies(group.query);
+    if (!this.#stillOpen() || !this.#groups.has(group.key))
+      return;
+    this.#unindexGroup(group, group.dependencies);
+    group.dependencies = next;
+    this.#indexGroup(group, next);
+  }
+  async #stableDependencies(query) {
+    let before = await this.#host.currentProbe();
+    this.#throwIfClosed();
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const dependencies = await this.#host.dependencyTableIds(query);
+      this.#throwIfClosed();
+      const after = await this.#host.currentProbe();
+      this.#throwIfClosed();
+      if (!catalogChangedBetween(before, after))
+        return { dependencies, probe: after };
+      before = after;
+    }
+    throw new Error("Catalog kept changing while live-query dependencies were resolved");
+  }
+  async #executeGroup(group) {
+    if (group.execution !== void 0) {
+      this.#stats.sharedExecutions += 1;
+      return group.execution;
+    }
+    const execution = (async () => {
+      const executed = await this.#host.execute(group.query);
+      const digest = digestResult(executed);
+      const previous = group.result;
+      const changed = previous === void 0 || group.digest !== digest || !sameResult(previous, executed);
+      const retained = cloneResult(executed);
+      group.result = retained;
+      group.digest = digest;
+      return { result: retained, changed };
+    })();
+    group.execution = execution;
+    try {
+      return await execution;
+    } finally {
+      if (group.execution === execution)
+        group.execution = void 0;
+    }
+  }
+  #deliverResult(subscriber, result) {
+    if (subscriber.closed)
+      return;
+    subscriber.delivered = true;
+    subscriber.options.onChange(cloneResult(result));
+  }
+  #deliverInvalidation(subscriber, invalidation) {
+    if (subscriber.closed)
+      return;
+    subscriber.delivered = true;
+    subscriber.options.onInvalidate(invalidation);
+  }
+  notifyLocalCommit() {
+    this.#channel?.postMessage("minnow-commit");
+    this.#hint();
+  }
+  async refresh() {
+    this.#hint();
+    await this.#sweepChain;
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#channel?.removeEventListener("message", this.#channelListener);
+    if (this.#ownsChannel)
+      this.#channel?.close?.();
+    if (this.#pollTimer !== void 0)
+      clearInterval(this.#pollTimer);
+    const groups = [...this.#groups.values()];
+    this.#groups.clear();
+    this.#groupsByTable.clear();
+    for (const group of groups) {
+      const subscribers = [...group.subscribers];
+      group.subscribers.clear();
+      for (const subscriber of subscribers) {
         if (subscriber.closed)
-            return;
+          continue;
         subscriber.closed = true;
         this.#subscriptionCount -= 1;
-        group.subscribers.delete(subscriber);
-        if (complete)
-            subscriber.options.onComplete?.();
-        this.#removeEmptyGroup(group);
-    }
-    #removeEmptyGroup(group) {
-        if (group.subscribers.size !== 0)
-            return;
-        if (this.#groups.get(group.key) !== group)
-            return;
-        this.#groups.delete(group.key);
-        this.#unindexGroup(group, group.dependencies);
-    }
-    async #getOrOpenGroup(query) {
-        const key = queryKey(query);
-        const existing = this.#groups.get(key);
-        if (existing !== undefined) {
-            this.#stats.sharedExecutions += 1;
-            return existing;
-        }
-        const opening = this.#opening.get(key);
-        if (opening !== undefined) {
-            this.#stats.sharedExecutions += 1;
-            return opening;
-        }
-        if (this.#groups.size + this.#opening.size >= this.#maxGroups) {
-            throw new LiveQueryLimitError("group", this.#maxGroups);
-        }
-        const created = this.#openGroup(key, query);
-        this.#opening.set(key, created);
+        subscriber.options.onComplete?.();
+      }
+    }
+    this.#onClosed?.();
+  }
+  #hint() {
+    if (this.#closed)
+      return;
+    this.#stats.hints += 1;
+    if (this.#sweepQueued)
+      return;
+    this.#sweepQueued = true;
+    this.#sweepChain = this.#sweepChain.then(async () => {
+      this.#sweepQueued = false;
+      try {
+        await this.#sweep();
+      } catch (error) {
+        for (const group of this.#groups.values())
+          this.#notifyGroupError(group, error);
+      }
+    });
+  }
+  #stillOpen() {
+    return !this.#closed;
+  }
+  async #sweep() {
+    if (this.#closed || this.#groups.size === 0)
+      return;
+    this.#stats.versionChecks += 1;
+    const current = await this.#host.currentProbe();
+    if (!this.#stillOpen())
+      return;
+    const last = this.#lastProbe ?? current;
+    const anyLagging = [...this.#groups.values()].some((group) => !sameProbe(group.seenProbe, current));
+    if (sameProbe(last, current) && !anyLagging)
+      return;
+    const started = performance.now();
+    this.#stats.sweeps += 1;
+    const windowCache = /* @__PURE__ */ new Map();
+    const changedSince = (after) => {
+      const key = versionOrdinal(after);
+      let pending = windowCache.get(key);
+      if (pending === void 0) {
+        pending = this.#changedTablesSince(after, current.manifestVersion);
+        windowCache.set(key, pending);
+      }
+      return pending;
+    };
+    for (const group of [...this.#groups.values()]) {
+      if (!this.#stillOpen())
+        return;
+      if (group.subscribers.size === 0 || sameProbe(group.seenProbe, current))
+        continue;
+      const prior = group.seenProbe;
+      const catalogChanged = catalogChangedBetween(prior, current);
+      if (catalogChanged) {
         try {
-            return await created;
-        }
-        finally {
-            this.#opening.delete(key);
-        }
-    }
-    async #openGroup(key, query) {
-        const { dependencies, probe: after } = await this.#stableDependencies(query);
-        const group = {
-            key,
-            query,
-            dependencies,
-            subscribers: new Set(),
-            seenProbe: after,
-            result: undefined,
-            digest: undefined,
-            execution: undefined,
-        };
-        this.#groups.set(key, group);
-        this.#indexGroup(group, dependencies);
-        if (this.#lastProbe === undefined ||
-            versionOrdinal(after.manifestVersion) < versionOrdinal(this.#lastProbe.manifestVersion)) {
-            this.#lastProbe = after;
-        }
-        return group;
-    }
-    #indexGroup(group, dependencies) {
-        for (const tableId of dependencies) {
-            let groups = this.#groupsByTable.get(tableId);
-            if (groups === undefined) {
-                groups = new Set();
-                this.#groupsByTable.set(tableId, groups);
-            }
-            groups.add(group);
-        }
-    }
-    #unindexGroup(group, dependencies) {
-        for (const tableId of dependencies) {
-            const groups = this.#groupsByTable.get(tableId);
-            groups?.delete(group);
-            if (groups?.size === 0)
-                this.#groupsByTable.delete(tableId);
+          await this.#refreshDependencies(group);
+        } catch (error) {
+          this.#notifyGroupError(group, error);
+          continue;
         }
-    }
-    async #refreshDependencies(group) {
-        const { dependencies: next } = await this.#stableDependencies(group.query);
-        if (!this.#stillOpen() || !this.#groups.has(group.key))
-            return;
-        this.#unindexGroup(group, group.dependencies);
-        group.dependencies = next;
-        this.#indexGroup(group, next);
-    }
-    /** Resolve a view/table set inside a catalog-stable probe window or refuse stale indexing. */
-    async #stableDependencies(query) {
-        let before = await this.#host.currentProbe();
-        this.#throwIfClosed();
-        for (let attempt = 0; attempt < 8; attempt += 1) {
-            const dependencies = await this.#host.dependencyTableIds(query);
-            this.#throwIfClosed();
-            const after = await this.#host.currentProbe();
-            this.#throwIfClosed();
-            if (!catalogChangedBetween(before, after))
-                return { dependencies, probe: after };
-            before = after;
-        }
-        throw new Error("Catalog kept changing while live-query dependencies were resolved");
-    }
-    async #executeGroup(group) {
-        if (group.execution !== undefined) {
-            this.#stats.sharedExecutions += 1;
-            return group.execution;
+      }
+      let relevant = [];
+      let affected = catalogChanged;
+      if (!affected && prior.manifestVersion !== current.manifestVersion) {
+        const changed = await changedSince(prior.manifestVersion);
+        if (!this.#stillOpen())
+          return;
+        if (changed === "all")
+          affected = true;
+        else {
+          relevant = [...group.dependencies].filter((tableId) => changed.has(tableId));
+          affected = relevant.length > 0;
         }
-        const execution = (async () => {
-            const executed = await this.#host.execute(group.query);
-            const digest = digestResult(executed);
-            const previous = group.result;
-            const changed = previous === undefined || group.digest !== digest || !sameResult(previous, executed);
-            const retained = cloneResult(executed);
-            group.result = retained;
-            group.digest = digest;
-            return { result: retained, changed };
-        })();
-        group.execution = execution;
+      }
+      if (!affected) {
+        this.#stats.rerunsAvoided += 1;
+        group.seenProbe = current;
+        continue;
+      }
+      if (!catalogChanged && relevant.length > 0 && current.manifestVersion !== null && this.#host.changeCanAffect !== void 0) {
+        let canAffect;
         try {
-            return await execution;
-        }
-        finally {
-            if (group.execution === execution)
-                group.execution = undefined;
-        }
-    }
-    #deliverResult(subscriber, result) {
-        if (subscriber.closed)
-            return;
-        subscriber.delivered = true;
-        subscriber.options.onChange(cloneResult(result));
-    }
-    #deliverInvalidation(subscriber, invalidation) {
-        if (subscriber.closed)
-            return;
-        subscriber.delivered = true;
-        subscriber.options.onInvalidate(invalidation);
-    }
-    /** Called by the owning database after each local write commit; also hints other tabs. */
-    notifyLocalCommit() {
-        this.#channel?.postMessage("minnow-commit");
-        this.#hint();
-    }
-    /** Runs one authoritative probe and selective re-execution sweep. */
-    async refresh() {
-        this.#hint();
-        await this.#sweepChain;
-    }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        this.#channel?.removeEventListener("message", this.#channelListener);
-        if (this.#ownsChannel)
-            this.#channel?.close?.();
-        if (this.#pollTimer !== undefined)
-            clearInterval(this.#pollTimer);
-        const groups = [...this.#groups.values()];
-        this.#groups.clear();
-        this.#groupsByTable.clear();
-        for (const group of groups) {
-            const subscribers = [...group.subscribers];
-            group.subscribers.clear();
-            for (const subscriber of subscribers) {
-                if (subscriber.closed)
-                    continue;
-                subscriber.closed = true;
-                this.#subscriptionCount -= 1;
-                subscriber.options.onComplete?.();
-            }
+          canAffect = await this.#host.changeCanAffect(group.query, relevant, prior.manifestVersion, current.manifestVersion);
+        } catch {
+          canAffect = true;
         }
-        this.#onClosed?.();
-    }
-    #hint() {
-        if (this.#closed)
-            return;
-        this.#stats.hints += 1;
-        if (this.#sweepQueued)
-            return;
-        this.#sweepQueued = true;
-        this.#sweepChain = this.#sweepChain.then(async () => {
-            this.#sweepQueued = false;
-            try {
-                await this.#sweep();
-            }
-            catch (error) {
-                for (const group of this.#groups.values())
-                    this.#notifyGroupError(group, error);
-            }
-        });
-    }
-    #stillOpen() {
-        return !this.#closed;
-    }
-    async #sweep() {
-        if (this.#closed || this.#groups.size === 0)
-            return;
-        this.#stats.versionChecks += 1;
-        const current = await this.#host.currentProbe();
         if (!this.#stillOpen())
-            return;
-        const last = this.#lastProbe ?? current;
-        const anyLagging = [...this.#groups.values()].some((group) => !sameProbe(group.seenProbe, current));
-        if (sameProbe(last, current) && !anyLagging)
-            return;
-        const started = performance.now();
-        this.#stats.sweeps += 1;
-        const windowCache = new Map();
-        const changedSince = (after) => {
-            const key = versionOrdinal(after);
-            let pending = windowCache.get(key);
-            if (pending === undefined) {
-                pending = this.#changedTablesSince(after, current.manifestVersion);
-                windowCache.set(key, pending);
-            }
-            return pending;
-        };
-        for (const group of [...this.#groups.values()]) {
-            if (!this.#stillOpen())
-                return;
-            if (group.subscribers.size === 0 || sameProbe(group.seenProbe, current))
-                continue;
-            const prior = group.seenProbe;
-            const catalogChanged = catalogChangedBetween(prior, current);
-            if (catalogChanged) {
-                try {
-                    await this.#refreshDependencies(group);
-                }
-                catch (error) {
-                    this.#notifyGroupError(group, error);
-                    continue;
-                }
-            }
-            let relevant = [];
-            let affected = catalogChanged;
-            if (!affected && prior.manifestVersion !== current.manifestVersion) {
-                const changed = await changedSince(prior.manifestVersion);
-                if (!this.#stillOpen())
-                    return;
-                if (changed === "all")
-                    affected = true;
-                else {
-                    relevant = [...group.dependencies].filter((tableId) => changed.has(tableId));
-                    affected = relevant.length > 0;
-                }
-            }
-            if (!affected) {
-                this.#stats.rerunsAvoided += 1;
-                group.seenProbe = current;
-                continue;
-            }
-            if (!catalogChanged &&
-                relevant.length > 0 &&
-                current.manifestVersion !== null &&
-                this.#host.changeCanAffect !== undefined) {
-                let canAffect;
-                try {
-                    canAffect = await this.#host.changeCanAffect(group.query, relevant, prior.manifestVersion, current.manifestVersion);
-                }
-                catch {
-                    canAffect = true;
-                }
-                if (!this.#stillOpen())
-                    return;
-                if (!canAffect) {
-                    this.#stats.rerunsAvoided += 1;
-                    this.#stats.zoneSkips += 1;
-                    group.seenProbe = current;
-                    continue;
-                }
-            }
-            const resultSubscribers = [...group.subscribers].filter((subscriber) => subscriber.kind === "result" && !subscriber.closed);
-            const observers = [...group.subscribers].filter((subscriber) => subscriber.kind === "observer" && !subscriber.closed);
-            try {
-                let execution;
-                if (resultSubscribers.length > 0) {
-                    // An initial delivery may be executing against the pre-sweep snapshot. Waiting for it
-                    // here can deadlock callers that intentionally hold that execute while awaiting this
-                    // refresh. Leave the group dirty; once the initial delivery lands, the next refresh
-                    // re-runs it against `current`.
-                    if (group.result === undefined && group.execution !== undefined)
-                        continue;
-                    this.#stats.reruns += 1;
-                    execution = await this.#executeGroup(group);
-                    if (!this.#stillOpen() || !this.#groups.has(group.key))
-                        continue;
-                }
-                for (const observer of observers) {
-                    try {
-                        this.#deliverInvalidation(observer, { ...current, initial: false });
-                        this.#stats.invalidations += 1;
-                    }
-                    catch (error) {
-                        observer.options.onError?.(error);
-                    }
-                }
-                if (execution !== undefined) {
-                    if (execution.changed) {
-                        for (const subscriber of resultSubscribers) {
-                            try {
-                                this.#deliverResult(subscriber, execution.result);
-                            }
-                            catch (error) {
-                                subscriber.options.onError?.(error);
-                            }
-                        }
-                    }
-                    else {
-                        this.#stats.notificationsSuppressed += resultSubscribers.length;
-                    }
-                }
-                group.seenProbe = current;
-            }
-            catch (error) {
-                // Do not advance seenProbe. A refresh with no newer commit retries the dirty group.
-                this.#notifyGroupError(group, error);
-            }
+          return;
+        if (!canAffect) {
+          this.#stats.rerunsAvoided += 1;
+          this.#stats.zoneSkips += 1;
+          group.seenProbe = current;
+          continue;
         }
-        this.#lastProbe = current;
-        this.#stats.lastSweepMs = performance.now() - started;
-    }
-    #notifyGroupError(group, error) {
-        for (const subscriber of group.subscribers) {
-            if (subscriber.closed)
-                continue;
-            subscriber.options.onError?.(error);
+      }
+      const resultSubscribers = [...group.subscribers].filter((subscriber) => subscriber.kind === "result" && !subscriber.closed);
+      const observers = [...group.subscribers].filter((subscriber) => subscriber.kind === "observer" && !subscriber.closed);
+      try {
+        let execution;
+        if (resultSubscribers.length > 0) {
+          if (group.result === void 0 && group.execution !== void 0)
+            continue;
+          this.#stats.reruns += 1;
+          execution = await this.#executeGroup(group);
+          if (!this.#stillOpen() || !this.#groups.has(group.key))
+            continue;
         }
-    }
-    /** Unions persisted table change sets in (after, until], widening on any history gap. */
-    async #changedTablesSince(after, until) {
-        if (until === null || after === until)
-            return new Set();
-        const changed = new Set();
-        let cursor = after;
-        let expected = (after ?? -1) + 1;
-        for (;;) {
-            const page = await this.#host.manifestPage(cursor, 64);
-            for (const manifest of page.records) {
-                if (manifest.version > until)
-                    return changed;
-                if (manifest.version !== expected)
-                    return "all";
-                expected += 1;
-                for (const tableId of manifest.changedTableIds)
-                    changed.add(tableId);
-                if (manifest.version === until)
-                    return changed;
+        for (const observer of observers) {
+          try {
+            this.#deliverInvalidation(observer, { ...current, initial: false });
+            this.#stats.invalidations += 1;
+          } catch (error) {
+            observer.options.onError?.(error);
+          }
+        }
+        if (execution !== void 0) {
+          if (execution.changed) {
+            for (const subscriber of resultSubscribers) {
+              try {
+                this.#deliverResult(subscriber, execution.result);
+              } catch (error) {
+                subscriber.options.onError?.(error);
+              }
             }
-            if (page.nextCursor === null)
-                return expected > until ? changed : "all";
-            cursor = page.nextCursor;
+          } else {
+            this.#stats.notificationsSuppressed += resultSubscribers.length;
+          }
         }
-    }
+        group.seenProbe = current;
+      } catch (error) {
+        this.#notifyGroupError(group, error);
+      }
+    }
+    this.#lastProbe = current;
+    this.#stats.lastSweepMs = performance.now() - started;
+  }
+  #notifyGroupError(group, error) {
+    for (const subscriber of group.subscribers) {
+      if (subscriber.closed)
+        continue;
+      subscriber.options.onError?.(error);
+    }
+  }
+  async #changedTablesSince(after, until) {
+    if (until === null || after === until)
+      return /* @__PURE__ */ new Set();
+    const changed = /* @__PURE__ */ new Set();
+    let cursor = after;
+    let expected = (after ?? -1) + 1;
+    for (; ; ) {
+      const page = await this.#host.manifestPage(cursor, 64);
+      for (const manifest of page.records) {
+        if (manifest.version > until)
+          return changed;
+        if (manifest.version !== expected)
+          return "all";
+        expected += 1;
+        for (const tableId of manifest.changedTableIds)
+          changed.add(tableId);
+        if (manifest.version === until)
+          return changed;
+      }
+      if (page.nextCursor === null)
+        return expected > until ? changed : "all";
+      cursor = page.nextCursor;
+    }
+  }
 }
 import { copyDate, dateMilliseconds } from "../date-value.js";
+export {
+  DEFAULT_LIVE_QUERY_MAX_GROUPS,
+  DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS,
+  LiveQueryLimitError2 as LiveQueryLimitError,
+  LiveQuerySet,
+  MAX_LIVE_QUERY_GROUPS,
+  MAX_LIVE_QUERY_SETS_PER_DATABASE,
+  MAX_LIVE_QUERY_SUBSCRIPTIONS
+};