@_linked/core 2.25.0 → 2.27.0

package/lib/esm/live/LiveQueryStore.js

@@ -0,0 +1,729 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { LinkedStorage } from '../utils/LinkedStorage.js';
+import { subscribeQueryContext, UnresolvedContextError } from '../queries/QueryContext.js';
+import { resolveContextId } from '../queries/ContextRef.js';
+import { subscribeQueryDispatch } from '../queries/queryDispatch.js';
+import { mutationEffects, queryDependencies, } from '../queries/queryDependencies.js';
+import { getShapeClass } from '../utils/ShapeClass.js';
+import { effectsHash, normalizeChange } from './changes.js';
+import { selectInstances } from './matcher.js';
+import { kindOf, paramsKey, splitQuery, stableStringify, stripSubjects, } from './keys.js';
+import { setLiveQueryStore, peekLiveQueryStore } from './registry.js';
+const IDLE = Object.freeze({ status: 'pending', notFound: false, refreshing: false });
+// ---------------------------------------------------------------------------
+// Store
+// ---------------------------------------------------------------------------
+/**
+ * Holds every live query in the runtime: templates (what is read) and
+ * instances (what it is applied to, and the data). Framework-free; UI layers
+ * subscribe to instances. One store per runtime, registered on `globalThis`
+ * (see `registry.ts`).
+ */
+export class LiveQueryStore {
+    constructor() {
+        this.options = { gcMs: 30000, echoMs: 50 };
+        /** @internal */
+        this._templates = new Map();
+        /** @internal Indexes read by the change matcher. */
+        this.templatesByProp = new Map();
+        /** @internal */
+        this.templatesByShape = new Map();
+        /** @internal */
+        this.instancesById = new Map();
+        this._disposers = [];
+        this._feeds = new Map();
+        this._recentChanges = new Map();
+        this._pendingRefetch = new Set();
+        this._flushScheduled = false;
+        this._disposers.push(subscribeQueryContext((name) => this._onContextChange(name)));
+        this._disposers.push(subscribeQueryDispatch((e) => this._onDispatch(e)));
+        this._disposers.push(LinkedStorage.onRoutingChanged(() => this._onRoutingChanged()));
+        this._scanDatasets();
+    }
+    // -------------------------------------------------------------------------
+    // Templates
+    // -------------------------------------------------------------------------
+    /** Register (or find) the template of `query`. Options merge into an existing template. */
+    template(query, opts = {}) {
+        return this._template(splitQuery(query).templateJson, query, opts);
+    }
+    _template(templateJson, query, opts) {
+        const key = stableStringify(templateJson);
+        let t = this._templates.get(key);
+        if (!t) {
+            t = {
+                key,
+                kind: kindOf(query),
+                json: templateJson,
+                builder: stripSubjects(query),
+                shapeIri: typeof templateJson.shape === 'string' ? templateJson.shape : undefined,
+                reactive: true,
+                pinned: false,
+                instances: new Map(),
+            };
+            this._templates.set(key, t);
+        }
+        if (opts.name !== undefined)
+            t.name = opts.name;
+        if (opts.reactive !== undefined)
+            t.reactive = opts.reactive;
+        if (opts.pinned)
+            t.pinned = true;
+        return t;
+    }
+    /** The registered templates (for database tuning, devtools). */
+    templates() {
+        return [...this._templates.values()].map((t) => ({ key: t.key, kind: t.kind, name: t.name, json: t.json }));
+    }
+    /** Compute the dependencies of every template now (they are otherwise computed on first use). */
+    prepare() {
+        for (const t of this._templates.values())
+            this.depsOf(t);
+    }
+    /**
+     * The watch set of a template, computed once. When a query context used in
+     * `where` is not set yet, lowering throws; the template then gets provisional
+     * dependencies (its shape only) and is recomputed on its next use, which the
+     * context change triggers.
+     */
+    depsOf(template) {
+        if (template.deps && !template.depsProvisional)
+            return template.deps;
+        try {
+            template.deps = queryDependencies(template.builder);
+            template.depsProvisional = false;
+        }
+        catch (err) {
+            if (!(err instanceof UnresolvedContextError))
+                throw err;
+            if (template.deps)
+                return template.deps; // still provisional
+            template.deps = {
+                narrow: new Set(),
+                filter: new Set(),
+                hidden: new Set(),
+                shapes: new Set(template.shapeIri ? [template.shapeIri] : []),
+                unbound: false,
+            };
+            template.depsProvisional = true;
+        }
+        this._index(template);
+        return template.deps;
+    }
+    _index(t) {
+        const deps = t.deps;
+        for (const set of [deps.narrow, deps.filter, deps.hidden]) {
+            for (const p of set)
+                addToIndex(this.templatesByProp, p, t);
+        }
+        for (const s of deps.shapes)
+            addToIndex(this.templatesByShape, s, t);
+    }
+    _unindexTemplate(t) {
+        for (const set of this.templatesByProp.values())
+            set.delete(t);
+        for (const set of this.templatesByShape.values())
+            set.delete(t);
+    }
+    // -------------------------------------------------------------------------
+    // Instances and handles
+    // -------------------------------------------------------------------------
+    /** @internal Get or create the instance of `template` for `params`, executing `builder`. */
+    instance(template, params, builder) {
+        const pk = paramsKey(params);
+        let inst = template.instances.get(pk);
+        if (!inst) {
+            this.depsOf(template); // index the template before its first instance exists
+            inst = {
+                key: `${template.key}|${pk}`,
+                template,
+                params,
+                builder,
+                state: IDLE,
+                seq: 0,
+                inflight: false,
+                staleWhileInflight: false,
+                ids: new Set(),
+                listeners: new Set(),
+                dropped: false,
+            };
+            template.instances.set(pk, inst);
+        }
+        return inst;
+    }
+    /**
+     * Subscribe to `query`. The first listener on an instance starts its fetch;
+     * identical queries share one instance and one request. A handle created
+     * without a listener holds nothing: its instance is released after the grace
+     * period unless something subscribes.
+     */
+    subscribe(query, listener, opts = {}) {
+        const { templateJson, params } = splitQuery(query);
+        const template = this._template(templateJson, query, opts);
+        const inst = this.instance(template, params, query);
+        if (inst.listeners.size === 0)
+            this._scheduleGc(inst);
+        const handle = new LiveQueryHandle(this, inst);
+        if (listener)
+            handle.subscribe(listener);
+        return handle;
+    }
+    /** @internal The live instance for a possibly dropped one (same template, params and builder). */
+    _resolve(inst) {
+        var _a;
+        if (!inst.dropped)
+            return inst;
+        if (inst.movedTo)
+            return this._resolve(inst.movedTo);
+        const t = (_a = this._templates.get(inst.template.key)) !== null && _a !== void 0 ? _a : this._template(inst.template.json, inst.builder, {});
+        return this.instance(t, inst.params, inst.builder);
+    }
+    /** @internal */
+    _attach(inst, listener) {
+        this._cancelGc(inst);
+        inst.listeners.add(listener);
+        if (inst.state.status === 'pending' && !inst.inflight) {
+            void this._fetch(inst);
+        }
+    }
+    /** @internal */
+    _detach(inst, listener) {
+        inst.listeners.delete(listener);
+        if (inst.listeners.size === 0 && !inst.dropped)
+            this._scheduleGc(inst);
+    }
+    /** Refetch an instance, keeping its data on screen. Resolves when that request settles. */
+    refresh(inst) {
+        return this._fetch(inst);
+    }
+    /**
+     * Local edit of an instance's data. Never touches the store. A patched
+     * instance counts as loaded (`success`), so `await live` resolves with it.
+     */
+    patch(inst, partial) {
+        const current = inst.state.data;
+        const mergeable = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+        const next = typeof partial === 'function'
+            ? partial(current)
+            : mergeable(current) && mergeable(partial)
+                ? Object.assign(Object.assign({}, current), partial) : partial;
+        const status = inst.state.status === 'error' ? 'error' : 'success';
+        this._setState(inst, Object.assign(Object.assign({}, inst.state), { status, data: next, notFound: next === null }));
+        this._collectIds(inst, next);
+    }
+    /**
+     * Refetch every instance matching `target`: a shape class or shape IRI
+     * (everything that scans or traverses it, as after a delete), a node
+     * reference (`{id}`), a query (its template), or a template. Never folded
+     * with other change events.
+     */
+    invalidate(target) {
+        var _a, _b;
+        if (typeof target === 'function' || typeof target === 'string') {
+            const shape = typeof target === 'string' ? target : (_a = target.shape) === null || _a === void 0 ? void 0 : _a.id;
+            if (!shape)
+                throw new Error('invalidate(): the shape class has no registered shape.');
+            this.publish({ effects: { op: 'delete', shape, props: new Set(), ids: undefined, membership: new Set([shape]) } }, 'manual');
+            return;
+        }
+        const instances = new Set();
+        if (isTemplate(target)) {
+            for (const i of target.instances.values())
+                instances.add(i);
+        }
+        else if (typeof target.__queryKind === 'string') {
+            const t = this._templates.get(stableStringify(splitQuery(target).templateJson));
+            if (t)
+                for (const i of t.instances.values())
+                    instances.add(i);
+        }
+        else if (typeof target.id === 'string') {
+            for (const i of (_b = this.instancesById.get(target.id)) !== null && _b !== void 0 ? _b : [])
+                instances.add(i);
+        }
+        this._refetchAll(instances);
+    }
+    /** @internal Refetch a set of instances, folding in-flight ones into one follow-up request. */
+    _refetchAll(instances) {
+        for (const inst of instances) {
+            if (inst.listeners.size === 0 || inst.dropped)
+                continue; // nobody is watching; it refetches when subscribed again
+            if (inst.inflight)
+                inst.staleWhileInflight = true;
+            else
+                void this._fetch(inst);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Change sources
+    // -------------------------------------------------------------------------
+    /**
+     * Tell the store that data changed. Every source ends here: local mutations
+     * (automatically, origin `local`), dataset change feeds (`feed`), application
+     * code via `publishChange()` (`app`) and `invalidate()` (`manual`).
+     *
+     * A local change and its remote confirmation carry identical effects; when
+     * they arrive within `options.echoMs` of each other they refetch once. Two
+     * events of the same origin are never folded — two writes to the same node
+     * in quick succession are two changes — and manual invalidations never are.
+     */
+    publish(event, origin = 'app') {
+        const effects = normalizeChange(event);
+        if (origin !== 'manual') {
+            const hash = effectsHash(effects);
+            const now = Date.now();
+            const prev = this._recentChanges.get(hash);
+            if (prev && prev.origin !== 'manual' && prev.origin !== origin && now - prev.at < this.options.echoMs) {
+                return; // the echo of a change already applied
+            }
+            this._recentChanges.set(hash, { at: now, origin });
+            if (this._recentChanges.size > 256) {
+                // Bounded: anything older than the echo window can no longer fold with a newcomer.
+                for (const [h, r] of this._recentChanges)
+                    if (now - r.at >= this.options.echoMs)
+                        this._recentChanges.delete(h);
+            }
+        }
+        for (const inst of selectInstances(this, effects))
+            this._pendingRefetch.add(inst);
+        this._scheduleFlush();
+    }
+    _scheduleFlush() {
+        if (this._flushScheduled)
+            return;
+        this._flushScheduled = true;
+        queueMicrotask(() => {
+            this._flushScheduled = false;
+            const batch = this._pendingRefetch;
+            this._pendingRefetch = new Set();
+            this._refetchAll(batch);
+        });
+    }
+    /**
+     * Local mutations. Select and ask events are ignored: the store's own fetches
+     * run through the same dispatch and must not feed back into it.
+     */
+    _onDispatch(e) {
+        var _a, _b;
+        if (e.kind !== 'create' && e.kind !== 'update' && e.kind !== 'delete')
+            return;
+        const query = e.query;
+        const dataset = (_a = e.target) !== null && _a !== void 0 ? _a : LinkedStorage.getDatasetForShapeClass((((_b = query.shape) === null || _b === void 0 ? void 0 : _b.id) ? getShapeClass(query.shape.id) : undefined));
+        if (dataset === null || dataset === void 0 ? void 0 : dataset.authoritativeChanges)
+            return; // the dataset's own feed will report it
+        e.result.then((result) => {
+            let effects;
+            try {
+                effects = mutationEffects(e.query, result);
+            }
+            catch (err) {
+                console.error('[linked] could not derive the effects of a mutation; live queries were not refetched', err);
+                return;
+            }
+            this.publish({ effects }, 'local');
+        }, () => { });
+    }
+    /** Subscribe to the change feeds of the datasets currently routed; drop feeds of datasets that left. */
+    _scanDatasets() {
+        const current = new Set(LinkedStorage.getDatasets());
+        for (const [dataset, off] of [...this._feeds]) {
+            if (!current.has(dataset)) {
+                off();
+                this._feeds.delete(dataset);
+            }
+        }
+        for (const dataset of current) {
+            if (typeof dataset.subscribeChanges !== 'function' || this._feeds.has(dataset))
+                continue;
+            const off = dataset.subscribeChanges((event) => {
+                try {
+                    this.publish(event, 'feed');
+                }
+                catch (err) {
+                    console.error('[linked] a dataset change event could not be applied', err);
+                }
+            });
+            this._feeds.set(dataset, off);
+        }
+    }
+    /**
+     * Storage changed (a dataset was set, pinned or unpinned): what is cached may
+     * come from a store that no longer answers, so instances nobody watches are
+     * dropped and watched ones fetch again. Also refreshes the feed subscriptions.
+     */
+    _onRoutingChanged() {
+        this._scanDatasets();
+        this._recentChanges.clear();
+        for (const t of [...this._templates.values()]) {
+            for (const inst of [...t.instances.values()]) {
+                if (inst.listeners.size === 0)
+                    this._dropInstance(inst);
+                else
+                    this._refetchAll([inst]);
+            }
+        }
+    }
+    /** Drop every template and instance (tests). Subscriptions to sources stay. */
+    reset() {
+        for (const t of [...this._templates.values()]) {
+            for (const i of [...t.instances.values()])
+                this._dropInstance(i, true);
+        }
+        this._templates.clear();
+        this.templatesByProp.clear();
+        this.templatesByShape.clear();
+        this.instancesById.clear();
+        this._recentChanges.clear();
+        this._pendingRefetch.clear();
+    }
+    /** @internal */
+    dispose() {
+        this.reset();
+        for (const off of this._disposers)
+            off();
+        for (const off of this._feeds.values())
+            off();
+        this._feeds.clear();
+    }
+    // -------------------------------------------------------------------------
+    // Fetching
+    // -------------------------------------------------------------------------
+    _fetch(inst) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unresolvedSubject = !!inst.params.contextName && !inst.params.subject;
+            if (!LinkedStorage.isInitialised() || unresolvedSubject) {
+                // Nothing to request yet. Stay quiet if that is already what listeners know.
+                if (inst.state.status !== 'pending' || inst.state.refreshing) {
+                    this._setState(inst, Object.assign(Object.assign({}, inst.state), { status: 'pending', refreshing: false }));
+                }
+                return;
+            }
+            if (inst.template.depsProvisional)
+                this.depsOf(inst.template); // a context may have landed
+            const seq = ++inst.seq;
+            inst.inflight = true;
+            const hasData = inst.state.data !== undefined;
+            this._setState(inst, Object.assign(Object.assign({}, inst.state), { status: hasData ? inst.state.status : 'loading', refreshing: hasData }));
+            try {
+                // `exec()` is the same path `await query` takes: dispatch, count/ask
+                // contracts, error wrapping. The store adds nothing of its own to it.
+                const data = yield inst.builder.exec();
+                if (seq !== inst.seq)
+                    return;
+                this._applyResult(inst, data);
+            }
+            catch (err) {
+                if (seq !== inst.seq)
+                    return;
+                this._setState(inst, Object.assign(Object.assign({}, inst.state), { status: 'error', error: err instanceof Error ? err : new Error(String(err)), refreshing: false }));
+            }
+            finally {
+                if (seq === inst.seq) {
+                    inst.inflight = false;
+                    if (inst.staleWhileInflight) {
+                        inst.staleWhileInflight = false;
+                        void this._fetch(inst);
+                    }
+                }
+            }
+        });
+    }
+    _applyResult(inst, data) {
+        const notFound = data === null && inst.template.kind === 'select' && !!(inst.params.subject || inst.params.one);
+        if (inst.state.status === 'success' && deepEqual(inst.state.data, data)) {
+            // Structural sharing: same data, keep the reference and stay quiet.
+            if (inst.state.refreshing)
+                this._setState(inst, Object.assign(Object.assign({}, inst.state), { refreshing: false, error: undefined }));
+            return;
+        }
+        this._collectIds(inst, data);
+        this._setState(inst, { status: 'success', data, error: undefined, notFound, refreshing: false });
+    }
+    _collectIds(inst, data) {
+        var _a;
+        const ids = new Set();
+        if (inst.params.subject)
+            ids.add(inst.params.subject);
+        for (const s of (_a = inst.params.subjects) !== null && _a !== void 0 ? _a : [])
+            ids.add(s);
+        collectIds(data, ids);
+        for (const old of inst.ids)
+            if (!ids.has(old))
+                removeFromIndex(this.instancesById, old, inst);
+        for (const id of ids)
+            if (!inst.ids.has(id))
+                addToIndex(this.instancesById, id, inst);
+        inst.ids = ids;
+    }
+    _setState(inst, state) {
+        inst.state = state;
+        for (const l of [...inst.listeners]) {
+            try {
+                l(state);
+            }
+            catch (err) {
+                console.error('[linked] live query listener failed', err);
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Query context
+    // -------------------------------------------------------------------------
+    /**
+     * A query context changed. An instance whose *subject* is that context is
+     * re-keyed to the new id (the builder resolves the context lazily, so it is
+     * reused); an instance that references it in `where` just fetches again.
+     */
+    _onContextChange(name) {
+        var _a;
+        const resolved = resolveContextId(name, false);
+        for (const t of [...this._templates.values()]) {
+            for (const inst of [...t.instances.values()]) {
+                if ((_a = inst.params.contextNames) === null || _a === void 0 ? void 0 : _a.includes(name)) {
+                    if (t.depsProvisional) {
+                        this._unindexTemplate(t);
+                        this.depsOf(t);
+                    }
+                    if (inst.listeners.size > 0)
+                        this._refetchAll([inst]);
+                }
+                if (inst.params.contextName !== name)
+                    continue;
+                const params = Object.assign({}, inst.params);
+                if (resolved)
+                    params.subject = resolved;
+                else
+                    delete params.subject;
+                if (paramsKey(params) === paramsKey(inst.params))
+                    continue;
+                // Move the listeners to the instance for the new subject and drop the old one.
+                const next = this.instance(t, params, inst.builder);
+                this._cancelGc(next);
+                const listeners = [...inst.listeners];
+                inst.listeners.clear();
+                inst.seq++; // any in-flight response for the old subject is now stale
+                inst.movedTo = next;
+                this._dropInstance(inst, true);
+                for (const l of listeners)
+                    next.listeners.add(l);
+                if (next.listeners.size > 0) {
+                    if (!resolved)
+                        this._setState(next, Object.assign({}, IDLE));
+                    else if (next.state.status === 'pending' && !next.inflight)
+                        void this._fetch(next);
+                    else
+                        this._setState(next, next.state); // publish the cached state to the moved listeners
+                }
+                else {
+                    this._scheduleGc(next);
+                }
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // GC
+    // -------------------------------------------------------------------------
+    /** Remove an instance from its template (and the template when it is empty and not pinned). */
+    _dropInstance(inst, keepTemplate = false) {
+        this._cancelGc(inst);
+        inst.dropped = true;
+        const t = inst.template;
+        if (t.instances.get(paramsKey(inst.params)) === inst)
+            t.instances.delete(paramsKey(inst.params));
+        for (const id of inst.ids)
+            removeFromIndex(this.instancesById, id, inst);
+        if (!keepTemplate && t.instances.size === 0 && !t.pinned) {
+            this._templates.delete(t.key);
+            this._unindexTemplate(t);
+        }
+    }
+    _scheduleGc(inst) {
+        var _a, _b;
+        this._cancelGc(inst);
+        // `unref` so a pending grace period never keeps a Node process (or a test
+        // runner) alive.
+        const timer = setTimeout(() => {
+            inst.gcTimer = undefined;
+            if (inst.listeners.size > 0)
+                return;
+            this._dropInstance(inst);
+        }, this.options.gcMs);
+        (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        inst.gcTimer = timer;
+    }
+    _cancelGc(inst) {
+        if (inst.gcTimer) {
+            clearTimeout(inst.gcTimer);
+            inst.gcTimer = undefined;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Handle
+// ---------------------------------------------------------------------------
+class LiveQueryHandle {
+    constructor(store, inst) {
+        this.store = store;
+        this._mine = new Set();
+        this._inst = inst;
+    }
+    /** The current instance, re-resolved if the store dropped the one this handle held. */
+    get inst() {
+        if (this._inst.dropped)
+            this._inst = this.store._resolve(this._inst);
+        return this._inst;
+    }
+    get state() {
+        return this.inst.state;
+    }
+    get key() {
+        return this.inst.key;
+    }
+    subscribe(listener) {
+        const l = listener;
+        const inst = this.inst;
+        this._mine.add(l);
+        this.store._attach(inst, l);
+        return () => {
+            if (this._mine.delete(l))
+                this.store._detach(inst, l);
+        };
+    }
+    refresh() {
+        return this.store.refresh(this.inst);
+    }
+    patch(partial) {
+        this.store.patch(this.inst, partial);
+    }
+    close() {
+        const inst = this._inst;
+        for (const l of this._mine)
+            this.store._detach(inst, l);
+        this._mine.clear();
+    }
+    then(onfulfilled, onrejected) {
+        return this._firstResult().then(onfulfilled, onrejected);
+    }
+    /** Resolves with the first successful data; the subscription it needs is released afterwards. */
+    _firstResult() {
+        const s = this.state;
+        if (s.status === 'success')
+            return Promise.resolve(s.data);
+        if (s.status === 'error')
+            return Promise.reject(s.error);
+        return new Promise((resolve, reject) => {
+            const off = this.subscribe((st) => {
+                if (st.status === 'success') {
+                    off();
+                    resolve(st.data);
+                }
+                else if (st.status === 'error') {
+                    off();
+                    reject(st.error);
+                }
+            });
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function addToIndex(index, key, value) {
+    let set = index.get(key);
+    if (!set)
+        index.set(key, (set = new Set()));
+    set.add(value);
+}
+function removeFromIndex(index, key, value) {
+    const set = index.get(key);
+    if (!set)
+        return;
+    set.delete(value);
+    if (set.size === 0)
+        index.delete(key);
+}
+function isTemplate(v) {
+    return !!v && typeof v === 'object' && 'instances' in v && 'builder' in v;
+}
+/** Every string value under an `id` key, at any depth. */
+export function collectIds(value, into) {
+    if (Array.isArray(value)) {
+        for (const v of value)
+            collectIds(v, into);
+    }
+    else if (value && typeof value === 'object' && !(value instanceof Date)) {
+        for (const [k, v] of Object.entries(value)) {
+            if (k === 'id' && typeof v === 'string')
+                into.add(v);
+            else if (v && typeof v === 'object')
+                collectIds(v, into);
+        }
+    }
+    return into;
+}
+/** Deep equality over the plain-data results the store holds (objects, arrays, dates, primitives). */
+export function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a instanceof Date || b instanceof Date) {
+        return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((v, i) => deepEqual(v, b[i]));
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        return ka.every((k) => deepEqual(a[k], b[k]));
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+/** The runtime's live-query store (registered on `globalThis` when this module loads). */
+export function getLiveQueryStore() {
+    let store = peekLiveQueryStore();
+    if (!store) {
+        store = new LiveQueryStore();
+        setLiveQueryStore(store);
+    }
+    return store;
+}
+/** Publish a change from application code (your own transport, a server push). */
+export function publishChange(event) {
+    getLiveQueryStore().publish(event, 'app');
+}
+/** Refetch every live query that `target` can have affected. See {@link LiveQueryStore.invalidate}. */
+export function invalidate(target) {
+    getLiveQueryStore().invalidate(target);
+}
+/** Replace the store with a fresh one (tests). */
+export function resetLiveQueryStore() {
+    var _a;
+    (_a = peekLiveQueryStore()) === null || _a === void 0 ? void 0 : _a.dispose();
+    const store = new LiveQueryStore();
+    setLiveQueryStore(store);
+    return store;
+}
+// Register on load: importing this module is what makes `.live()` work.
+if (!peekLiveQueryStore())
+    setLiveQueryStore(new LiveQueryStore());
+//# sourceMappingURL=LiveQueryStore.js.map