@minnowdb/core 0.2.1 → 0.4.0

package/dist/engine/live.js

@@ -1,13 +1,22 @@
-/** Companion to LiveQuerySet#stillOpen for the per-subscription flag. */
-function isSubscriptionClosed(subscription) {
-    return subscription.closed;
+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 class LiveQueryLimitError extends Error {
+    resource;
+    limit;
+    name = "LiveQueryLimitError";
+    constructor(resource, limit) {
+        super(resource === "set"
+            ? `A database cannot retain more than ${String(limit)} live-query sets`
+            : `A live-query set cannot retain more than ${String(limit)} ${resource} records`);
+        this.resource = resource;
+        this.limit = limit;
+    }
 }
 const digestScratch = new DataView(new ArrayBuffer(8));
-/**
- * A 32-bit FNV-1a digest of a result, mixed from typed values: a number's eight bytes, a
- * string's char codes, a tag per type and per null. Building a string per cell and hashing
- * that used to cost several times the query it digested.
- */
+/** Fast inequality filter. Equal digests are always followed by exact comparison. */
 function digestResult(result) {
     let hash = 0x811c9dc5;
     const mixByte = (byte) => {
@@ -18,9 +27,9 @@ function digestResult(result) {
         for (let index = 0; index < 8; index += 1)
             mixByte(digestScratch.getUint8(index));
     };
-    const mixString = (text) => {
-        for (let index = 0; index < text.length; index += 1) {
-            const code = text.charCodeAt(index);
+    const mixString = (value) => {
+        for (let index = 0; index < value.length; index += 1) {
+            const code = value.charCodeAt(index);
             mixByte(code & 0xff);
             mixByte(code >>> 8);
         }
@@ -45,20 +54,142 @@ function digestResult(result) {
                 mixByte(value ? 4 : 5);
             else {
                 mixByte(6);
-                mixNumber(value.getTime());
+                mixNumber(dateMilliseconds(value));
             }
         }
         mixByte(0xfe);
     }
     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);
+}
+function sameResult(left, right) {
+    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;
+    }
+    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;
+}
+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;
+}
+function cloneResult(result) {
+    const columns = [...result.columns];
+    return { columns, 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 queryKey(query) {
+    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;
+}
+function versionOrdinal(version) {
+    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;
+}
+/** 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);
+}
 export class LiveQuerySet {
     #host;
     #channel;
     #channelListener = () => {
         this.#hint();
     };
-    #subscriptions = new Set();
+    #groups = new Map();
+    #opening = new Map();
+    #groupsByTable = new Map();
+    #maxGroups;
+    #maxSubscriptions;
     #stats = {
         hints: 0,
         versionChecks: 0,
@@ -67,16 +198,25 @@ export class LiveQuerySet {
         rerunsAvoided: 0,
         zoneSkips: 0,
         notificationsSuppressed: 0,
+        invalidations: 0,
+        sharedExecutions: 0,
         lastSweepMs: 0,
     };
-    #lastSeenVersion = null;
+    #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;
@@ -101,52 +241,243 @@ export class LiveQuerySet {
     get stats() {
         return { ...this.#stats };
     }
-    /** Registers a query, delivers its initial result, and re-runs it when its tables change. */
-    async subscribe(query, options) {
+    #throwIfClosed() {
         if (this.#closed)
             throw new Error("Live query set is closed");
-        const dependencies = await this.#host.dependencyTableIds(query);
-        const version = await this.#host.currentVersion();
-        const subscription = {
-            query,
-            dependencies,
-            options,
-            digest: undefined,
-            seenVersion: version,
-            closed: false,
-        };
-        if (this.#lastSeenVersion === null || (version !== null && version < this.#lastSeenVersion)) {
-            this.#lastSeenVersion = version;
+    }
+    #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;
         }
-        const result = await this.#host.execute(query);
-        subscription.digest = digestResult(result);
-        this.#subscriptions.add(subscription);
+        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 {
-            options.onChange(result);
+            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) {
-            // A throwing initial handler would leak an unclosable subscription; unregister first.
-            subscription.closed = true;
-            this.#subscriptions.delete(subscription);
+            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: [...dependencies],
+            dependencyTableIds: [...group.dependencies],
             close: () => {
-                if (subscription.closed)
-                    return;
-                subscription.closed = true;
-                this.#subscriptions.delete(subscription);
-                subscription.options.onComplete?.();
+                this.#removeSubscriber(group, subscriber, true);
             },
         };
     }
+    #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 !== 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);
+        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);
+        }
+    }
+    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;
+        }
+        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;
+        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 version check and selective re-execution sweep. */
+    /** Runs one authoritative probe and selective re-execution sweep. */
     async refresh() {
         this.#hint();
         await this.#sweepChain;
@@ -160,14 +491,19 @@ export class LiveQuerySet {
             this.#channel?.close?.();
         if (this.#pollTimer !== undefined)
             clearInterval(this.#pollTimer);
-        const subscriptions = [...this.#subscriptions];
-        this.#subscriptions.clear();
-        // Wake every remaining subscriber so iterators and UI bindings end instead of hanging.
-        for (const subscription of subscriptions) {
-            if (subscription.closed)
-                continue;
-            subscription.closed = true;
-            subscription.options.onComplete?.();
+        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?.();
+            }
         }
         this.#onClosed?.();
     }
@@ -184,107 +520,152 @@ export class LiveQuerySet {
                 await this.#sweep();
             }
             catch (error) {
-                for (const subscription of this.#subscriptions) {
-                    subscription.options.onError?.(error);
-                }
+                for (const group of this.#groups.values())
+                    this.#notifyGroupError(group, error);
             }
         });
     }
-    /**
-     * Re-reads the closed flags through calls. `close()` runs while a sweep is suspended at an
-     * await, but control-flow analysis assumes flags cannot change across one, so a direct read
-     * would be narrowed to its pre-await value and the guard silently dropped.
-     */
     #stillOpen() {
         return !this.#closed;
     }
     async #sweep() {
-        if (this.#closed || this.#subscriptions.size === 0)
+        if (this.#closed || this.#groups.size === 0)
             return;
         this.#stats.versionChecks += 1;
-        const current = await this.#host.currentVersion();
-        if (!this.#stillOpen() || current === null)
+        const current = await this.#host.currentProbe();
+        if (!this.#stillOpen())
             return;
-        const anyLagging = [...this.#subscriptions].some((subscription) => !subscription.closed &&
-            (subscription.seenVersion === null || subscription.seenVersion < current));
-        if (current === this.#lastSeenVersion && !anyLagging)
+        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;
-        // The changed-table window starts at the set-level version, so it only gates subscriptions
-        // that were up to date there. A lagging subscription's window starts earlier at its own
-        // seenVersion, so it re-runs unconditionally — the digest suppresses no-op notifications.
-        const changed = current === this.#lastSeenVersion
-            ? new Set()
-            : await this.#changedTablesSince(this.#lastSeenVersion, current);
-        if (!this.#stillOpen())
-            return;
-        for (const subscription of [...this.#subscriptions]) {
-            if (subscription.closed)
+        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;
-            if (subscription.seenVersion !== null && subscription.seenVersion >= current)
+            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 (subscription.seenVersion === this.#lastSeenVersion) {
-                const affected = changed === "all" ||
-                    [...subscription.dependencies].some((tableId) => changed.has(tableId));
-                if (!affected) {
+            }
+            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;
-                    subscription.seenVersion = current;
+                    this.#stats.zoneSkips += 1;
+                    group.seenProbe = current;
                     continue;
                 }
-                if (changed !== "all" && this.#host.changeCanAffect !== undefined) {
-                    const relevant = [...subscription.dependencies].filter((tableId) => changed.has(tableId));
-                    let canAffect;
-                    try {
-                        canAffect = await this.#host.changeCanAffect(subscription.query, relevant, this.#lastSeenVersion, current);
-                    }
-                    catch {
-                        canAffect = true;
-                    }
-                    if (!this.#stillOpen())
-                        return;
-                    if (isSubscriptionClosed(subscription))
+            }
+            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;
-                    if (!canAffect) {
-                        this.#stats.rerunsAvoided += 1;
-                        this.#stats.zoneSkips += 1;
-                        subscription.seenVersion = current;
+                    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);
                     }
                 }
-            }
-            this.#stats.reruns += 1;
-            try {
-                const result = await this.#host.execute(subscription.query);
-                // The subscription (or the set) may have closed during the execute; a late onChange
-                // after onComplete would break the subscriber contract.
-                if (!this.#stillOpen() || isSubscriptionClosed(subscription))
-                    continue;
-                subscription.seenVersion = current;
-                const digest = digestResult(result);
-                if (digest === subscription.digest) {
-                    this.#stats.notificationsSuppressed += 1;
-                    continue;
+                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;
+                    }
                 }
-                subscription.digest = digest;
-                subscription.options.onChange(result);
+                group.seenProbe = current;
             }
             catch (error) {
-                if (!this.#stillOpen() || isSubscriptionClosed(subscription))
-                    continue;
-                subscription.seenVersion = current;
-                subscription.options.onError?.(error);
+                // Do not advance seenProbe. A refresh with no newer commit retries the dirty group.
+                this.#notifyGroupError(group, error);
             }
         }
-        this.#lastSeenVersion = current;
+        this.#lastProbe = current;
         this.#stats.lastSweepMs = performance.now() - started;
     }
-    /**
-     * Unions the persisted change sets of every manifest in (after, until], reading bounded pages.
-     * A missing manifest version or a manifest without a change set widens to "all" — correctness
-     * over selectivity.
-     */
+    #notifyGroupError(group, error) {
+        for (const subscriber of group.subscribers) {
+            if (subscriber.closed)
+                continue;
+            subscriber.options.onError?.(error);
+        }
+    }
+    /** 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;
@@ -296,18 +677,15 @@ export class LiveQuerySet {
                 if (manifest.version !== expected)
                     return "all";
                 expected += 1;
-                if (manifest.changedTableIds === undefined)
-                    return "all";
                 for (const tableId of manifest.changedTableIds)
                     changed.add(tableId);
                 if (manifest.version === until)
                     return changed;
             }
-            if (page.nextCursor === null) {
+            if (page.nextCursor === null)
                 return expected > until ? changed : "all";
-            }
             cursor = page.nextCursor;
         }
     }
 }
-//# sourceMappingURL=live.js.map
+import { copyDate, dateMilliseconds } from "../date-value.js";