@signaldb/svelte 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/base/core/src/WorkerDataAdapter.js

@@ -0,0 +1,749 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const queryId_1 = __importDefault(require("./utils/queryId"));
+const randomId_1 = __importDefault(require("./utils/randomId"));
+const batchOnNextTick_1 = __importDefault(require("./utils/batchOnNextTick"));
+const incrementalQueryUpdate_1 = require("./utils/incrementalQueryUpdate");
+const queryDelta_1 = require("./utils/queryDelta");
+const match_1 = __importDefault(require("./utils/match"));
+const modify_1 = __importDefault(require("./utils/modify"));
+const deepClone_1 = __importDefault(require("./utils/deepClone"));
+// The ids a selector names outright, or `null` when it asks something the ids alone cannot answer.
+// Deliberately strict: one key, `id`, holding a primitive or a lone `$in`. Anything else — another
+// field alongside it, an operator, a nested condition — falls back to matching, because guessing
+// wrong here would silently drop a row from a write.
+/**
+ * Extracts the ids a selector names outright.
+ * @param selector - The selector to inspect.
+ * @returns The named ids, or `null` when the selector asks more than ids can answer.
+ */
+function selectorIds(selector) {
+    if (selector == null || typeof selector !== 'object')
+        return null;
+    const keys = Object.keys(selector);
+    if (keys.length !== 1 || keys[0] !== 'id')
+        return null;
+    const value = selector.id;
+    if (value == null)
+        return null;
+    if (typeof value !== 'object')
+        return [value];
+    const valueKeys = Object.keys(value);
+    if (valueKeys.length !== 1 || valueKeys[0] !== '$in')
+        return null;
+    const inValues = value.$in;
+    return Array.isArray(inValues) ? inValues : null;
+}
+class WorkerDataAdapter {
+    worker;
+    options;
+    id;
+    isDisposed = false;
+    workerReady;
+    log = () => { };
+    collectionReady = new Map();
+    batchExecutionHelpers = new Map();
+    queries = {};
+    // Resolvers for `exec` calls that are still waiting for their response, keyed by message id.
+    // Together with the query registry above this is everything the shared dispatcher needs to route
+    // a message, which is why there is no longer a listener per request or per query.
+    pendingRequests = new Map();
+    // Writes that have been issued but not yet confirmed by the worker. Their
+    // effect is layered on top of each active query's last authoritative result
+    // in `getQueryResult`, so a cursor reflects a write immediately instead of
+    // waiting out the postMessage → SQLite write → re-executed query →
+    // postMessage round trip. Deliberately scoped to items that active queries
+    // already hold: this adapter must not turn into a full in-memory mirror of
+    // the backing store, and anything no active query holds isn't observable
+    // anyway. Dropped again once the write settles — on success the worker's
+    // own `queryUpdate` has already landed (it is posted before the write's
+    // response, and message order is preserved), on failure dropping it is the
+    // rollback.
+    //
+    // Held in three shapes, because each answers a different question cheaply and none of them
+    // answers all three: `writes` says which ids a settling write touched, `byId` says what an id
+    // looked like before the newest write touched it, and `flat` is the collapsed view every reader
+    // actually wants. They are maintained together, as writes arrive and settle.
+    pendingWrites = new Map();
+    pendingWriteSeq = 0;
+    // Bumped whenever a collection's pending writes change, in either direction. Anything derived
+    // from them is stale from that moment on.
+    pendingWriteVersions = new Map();
+    bumpPendingWriteVersion(collectionName) {
+        const current = this.pendingWriteVersions.get(collectionName) ?? 0;
+        this.pendingWriteVersions.set(collectionName, current + 1);
+    }
+    constructor(worker, options) {
+        this.worker = worker;
+        this.options = options;
+        this.id = this.options.id || 'default-worker-data-adapter';
+        if (this.options.log)
+            this.log = this.options.log;
+        this.workerReady = new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error('WorkerDataAdapter initialization timed out'));
+            }, 5000);
+            this.resolveWorkerReady = () => {
+                clearTimeout(timeoutId);
+                resolve();
+            };
+        });
+        this.worker.addEventListener('message', this.handleWorkerMessage);
+    }
+    resolveWorkerReady = () => { };
+    // The one and only message listener this adapter installs. Every response and every query update
+    // is routed from here by a map lookup. Listening per request and per query instead meant each
+    // incoming message was offered to every listener in turn, and each of them re-serialized its own
+    // selector to decide the message was not for it — turning a write that touches N queries into
+    // N² selector serializations before any of the actual work started.
+    handleWorkerMessage = (event) => {
+        const message = event.data;
+        if (message == null)
+            return;
+        if (message.workerId !== this.id)
+            return;
+        if (message.type === 'ready') {
+            this.resolveWorkerReady();
+            return;
+        }
+        if (message.type === 'response') {
+            if (message.id == null)
+                return;
+            const pending = this.pendingRequests.get(message.id);
+            if (!pending)
+                return;
+            this.pendingRequests.delete(message.id);
+            this.log('response', message.data ?? message.error);
+            if (message.error) {
+                pending.reject(message.error);
+            }
+            else {
+                pending.resolve(message.data);
+            }
+            return;
+        }
+        if (message.type === 'queryUpdate')
+            this.handleQueryUpdate(message.data, message.error ?? null);
+    };
+    handleQueryUpdate(data, error) {
+        if (data == null)
+            return;
+        const { collectionName, qid, selector, options, state, items, delta, } = data;
+        if (collectionName == null)
+            return;
+        const collectionQueries = this.queries[collectionName];
+        if (!collectionQueries)
+            return;
+        // The host names the query outright; deriving the id from the selector is only for messages
+        // that predate that (and for tests that hand-roll one).
+        const id = qid ?? (selector === undefined ? undefined : (0, queryId_1.default)(selector, options));
+        if (id == null)
+            return;
+        const query = collectionQueries.get(id);
+        if (!query)
+            return;
+        this.log('queryUpdate', query.selector, query.options, state, data ?? error);
+        let nextItems = items;
+        let deltaToPublish;
+        if (delta != null) {
+            // A delta only makes sense against the result it was computed from. If this adapter is
+            // holding something else — a message lost, a query re-registered underneath, a host and an
+            // adapter that disagree — applying it anyway would leave a result that silently drifts from
+            // the store. Refusing it keeps the last coherent result instead, and the next full answer
+            // puts things right. A delta describing no change at all is refused for the simpler reason
+            // that there is nothing to apply.
+            //
+            // The *state* the message carries is not part of that judgement, and used to be dropped
+            // along with the delta. A host that cannot answer a query from its previous result announces
+            // `'active'`, re-executes, and answers with a delta — which is empty whenever the write left
+            // this query's result as it was. The query then stayed `'active'` here for good, because no
+            // further message was coming to correct it: `Cursor#isLoading()` reported a first result
+            // still pending forever, and every screen gated on it showed its loading state forever.
+            const canApply = (0, queryDelta_1.canApplyQueryDelta)(query.items, delta);
+            if (!canApply || (0, queryDelta_1.isEmptyQueryDelta)(delta)) {
+                if (state === query.state)
+                    return;
+                this.updateQuery(collectionName, {
+                    selector: query.selector,
+                    options: query.options,
+                }, { state, error });
+                const settled = collectionQueries.get(id);
+                if (!settled)
+                    return;
+                // An empty delta is passed on as it came: it settles the query without asking anyone to
+                // recompute a result that did not change. One that could not be applied is not, so the
+                // consumer re-reads and the disagreement ends there.
+                settled.stateChangeCallbacks
+                    .forEach(callback => (0, queryDelta_1.callWithDelta)(callback, state, canApply ? delta : undefined));
+                return;
+            }
+            const pendingBefore = this.flattenPendingWrites(collectionName);
+            const servedBefore = pendingBefore == null
+                ? null
+                : this.servedResult(collectionName, query);
+            nextItems = (0, queryDelta_1.applyQueryDelta)(query.items, delta);
+            if (servedBefore == null) {
+                // Nothing is layered on top of the stored result, so what the host described is exactly
+                // what a reader of this query will see change.
+                deltaToPublish = delta;
+            }
+            else {
+                // A write is still in flight, and its effect has been shown to readers all along. What
+                // they see change is the difference between the two layered results — which, for the
+                // ordinary case of the host confirming the write that is in flight, is nothing at all.
+                this.updateQuery(collectionName, {
+                    selector: query.selector,
+                    options: query.options,
+                }, { state, error, items: nextItems });
+                const stored = collectionQueries.get(id);
+                if (!stored)
+                    return;
+                const servedDelta = (0, queryDelta_1.diffQueryResults)(servedBefore, this.servedResult(collectionName, stored));
+                if ((0, queryDelta_1.isEmptyQueryDelta)(servedDelta) && state === query.state)
+                    return;
+                stored.stateChangeCallbacks
+                    .forEach(callback => (0, queryDelta_1.callWithDelta)(callback, state, servedDelta));
+                return;
+            }
+        }
+        this.updateQuery(collectionName, {
+            selector: query.selector,
+            options: query.options,
+        }, { state, error, items: nextItems });
+        const updated = collectionQueries.get(id);
+        if (!updated)
+            return;
+        updated.stateChangeCallbacks.forEach(callback => (0, queryDelta_1.callWithDelta)(callback, state, deltaToPublish));
+    }
+    async exec(method, collectionName, ...args) {
+        await this.workerReady;
+        if (method !== 'isReady') {
+            const collectionReady = this.collectionReady.get(collectionName);
+            if (!collectionReady)
+                throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
+            await collectionReady;
+        }
+        if (this.isDisposed) {
+            throw new Error('WorkerDataAdapter is disposed');
+        }
+        return new Promise((resolve, reject) => {
+            const messageId = (0, randomId_1.default)();
+            this.pendingRequests.set(messageId, { resolve, reject });
+            this.worker.postMessage({
+                id: messageId,
+                workerId: this.id,
+                method,
+                args: [collectionName, ...args],
+            });
+        });
+    }
+    /**
+     * Issues a call whose result nobody is waiting for, and makes sure a failure has somewhere to
+     * go. A bare rejection here would surface as an uncaught error — which is what a disposed
+     * collection produced every time a cursor was cleaned up after it.
+     * @param method - The method to call on the worker.
+     * @param collectionName - The collection it applies to.
+     * @param args - The remaining arguments.
+     * @param onError - Called when the call fails, in place of merely logging it.
+     */
+    execInBackground(method, collectionName, args = [], onError) {
+        this.exec(method, collectionName, ...args).catch((error) => {
+            if (onError) {
+                onError(error);
+                return;
+            }
+            this.log(method, 'failed', error);
+        });
+    }
+    queryItemsById(query) {
+        if (!query.itemsById) {
+            query.itemsById = new Map(query.items.map(item => [item.id, item]));
+        }
+        return query.itemsById;
+    }
+    // The pending writes of a collection collapsed into one upsert/delete view, newest write winning.
+    // `null` when there are none, which is the overwhelmingly common case and the one every caller
+    // below short-circuits on. Maintained by the two helpers under it rather than rebuilt here, so
+    // this is a lookup whatever the size of the pending set — see `PendingWriteState`. The returned
+    // view is the live one: callers read it, never mutate it.
+    flattenPendingWrites(collectionName) {
+        const state = this.pendingWrites.get(collectionName);
+        if (!state || state.writes.size === 0)
+            return null;
+        return state.flat;
+    }
+    // Records one id's contribution from the write being registered. `seq` only ever grows, so the
+    // new entry is by construction the newest one for this id and therefore the one that wins.
+    static pushPendingEntry(state, id, item, seq) {
+        const stack = state.byId.get(id);
+        if (stack)
+            stack.push({ seq, item });
+        else
+            state.byId.set(id, [{ seq, item }]);
+        WorkerDataAdapter.writeFlatEntry(state, id, item);
+    }
+    // Takes one id's contribution back out as its write settles, and restores whatever the write
+    // below it said — or removes the id entirely when that was the only one.
+    static dropPendingEntry(state, id, seq) {
+        const stack = state.byId.get(id);
+        if (!stack)
+            return;
+        const index = stack.findIndex(entry => entry.seq === seq);
+        if (index !== -1)
+            stack.splice(index, 1);
+        const top = stack.at(-1);
+        if (!top) {
+            state.byId.delete(id);
+            state.flat.upserts.delete(id);
+            state.flat.deletes.delete(id);
+            return;
+        }
+        WorkerDataAdapter.writeFlatEntry(state, id, top.item);
+    }
+    static writeFlatEntry(state, id, item) {
+        if (item === null) {
+            state.flat.deletes.add(id);
+            state.flat.upserts.delete(id);
+            return;
+        }
+        state.flat.upserts.set(id, item);
+        state.flat.deletes.delete(id);
+    }
+    // The items an active query currently holds, deduplicated by id, plus whatever the pending writes
+    // add or remove — the only items this adapter knows about, and the set a selector-based write is
+    // resolved against locally. One pass over the queries rather than a merge per query.
+    // Whether a query's result is the items themselves rather than a projection of them. A write is
+    // resolved locally by applying its modifier to the item this adapter holds, and applying it to an
+    // item that has had fields removed produces something that is not the item — one that a selector
+    // naming a projected-away field no longer matches, so the row would vanish from every other
+    // query until the store answered. An item known only through a projection is therefore treated as
+    // not known at all: the write still happens, it simply is not shown before the store confirms it.
+    static providesFullItems(query) {
+        return query.options?.fields == null;
+    }
+    observableItems(collectionName) {
+        const byId = new Map();
+        this.queries[collectionName]?.forEach((query) => {
+            if (!WorkerDataAdapter.providesFullItems(query))
+                return;
+            query.items.forEach(item => byId.set(item.id, item));
+        });
+        const pending = this.flattenPendingWrites(collectionName);
+        if (pending) {
+            pending.upserts.forEach((item, id) => byId.set(id, item));
+            pending.deletes.forEach(id => byId.delete(id));
+        }
+        return [...byId.values()];
+    }
+    // The same answer as `observableItems` restricted to known ids — for the selector shapes that
+    // name them (`{ id }`, `{ id: { $in } }`), which is what an ordinary `updateOne`/`removeOne`
+    // carries. Costs a handful of map lookups instead of materialising every active query's result
+    // and running the matcher over all of it.
+    observableItemsByIds(collectionName, ids) {
+        const pending = this.flattenPendingWrites(collectionName);
+        const found = new Map();
+        ids.forEach((id) => {
+            if (pending?.deletes.has(id))
+                return;
+            const pendingItem = pending?.upserts.get(id);
+            if (pendingItem) {
+                found.set(id, pendingItem);
+                return;
+            }
+            const queries = this.queries[collectionName];
+            if (!queries)
+                return;
+            for (const query of queries.values()) {
+                if (!WorkerDataAdapter.providesFullItems(query))
+                    continue;
+                const item = this.queryItemsById(query).get(id);
+                if (item) {
+                    found.set(id, item);
+                    return;
+                }
+            }
+        });
+        return [...found.values()];
+    }
+    // Whether any pending write changes what this query would return. Answered against the pending
+    // set (small) and the query's id index, never by walking its items: a query no in-flight write
+    // touches — nearly all of them, nearly always — keeps its own array, so its readers skip both the
+    // merge and the re-filtering that would follow it.
+    // What `getQueryResult` answers: the query's last confirmed result with whatever writes are still
+    // in flight folded into it. Only the items those writes touch are examined — the rest matched
+    // when the store produced them and are carried over untouched, which is both what makes this cost
+    // the size of the pending writes rather than the size of the result, and what keeps a projected
+    // result from being re-matched against fields its projection has already dropped.
+    servedResult(collectionName, query) {
+        const pendingVersion = this.pendingWriteVersions.get(collectionName) ?? 0;
+        if (query.served
+            && query.served.fromItems === query.items
+            && query.served.pendingVersion === pendingVersion) {
+            return query.served.items;
+        }
+        const items = this.advanceServedResult(collectionName, query, pendingVersion)
+            ?? this.computeServedResult(collectionName, query);
+        query.served = { items, fromItems: query.items, pendingVersion };
+        return items;
+    }
+    // One step forward from the answer this query already had, instead of rebuilding it from every
+    // pending write. Only the ids the newest change touched are looked at, so a burst of writes costs
+    // each of them the size of that write — where rebuilding re-matched and re-projected the whole
+    // pending set per write, which is quadratic in the burst and was measured at twelve seconds for
+    // four thousand unsettled inserts against a single matching query.
+    //
+    // `null` means the step is not available and the caller has to rebuild: nothing to step from, a
+    // gap of more than one version, or a query shape whose result cannot be derived from itself — a
+    // projection cannot be re-matched against a selector naming fields it dropped, and a limited
+    // query is a window whose content can depend on rows it does not hold.
+    advanceServedResult(collectionName, query, pendingVersion) {
+        const served = query.served;
+        if (!served || served.fromItems !== query.items)
+            return null;
+        if (served.pendingVersion !== pendingVersion - 1)
+            return null;
+        if (!WorkerDataAdapter.providesFullItems(query) || query.options?.limit != null)
+            return null;
+        const state = this.pendingWrites.get(collectionName);
+        if (state?.lastChange == null || state.lastChange.version !== pendingVersion)
+            return null;
+        return (0, incrementalQueryUpdate_1.mergeChangesetIntoResult)(served.items, query.selector, query.options, this.changesetForIds(collectionName, query, state.lastChange.ids));
+    }
+    // What the named ids look like now — the pending value if one is still in flight for them, and
+    // otherwise whatever the last confirmed result said, which is what a settling write reverts to.
+    // The same rule answers a write arriving and a write settling, so both take the step above.
+    changesetForIds(collectionName, query, ids) {
+        const pending = this.flattenPendingWrites(collectionName);
+        const stored = this.queryItemsById(query);
+        const upserts = [];
+        const deletes = [];
+        ids.forEach((id) => {
+            const pendingItem = pending?.upserts.get(id);
+            if (pendingItem) {
+                upserts.push(pendingItem);
+                return;
+            }
+            if (pending?.deletes.has(id)) {
+                deletes.push(id);
+                return;
+            }
+            const storedItem = stored.get(id);
+            if (storedItem)
+                upserts.push(storedItem);
+            else
+                deletes.push(id);
+        });
+        return { upserts, deletes };
+    }
+    computeServedResult(collectionName, query) {
+        const pending = this.flattenPendingWrites(collectionName);
+        if (!pending)
+            return query.items;
+        const byId = this.queryItemsById(query);
+        let affected = false;
+        pending.deletes.forEach((id) => {
+            if (byId.has(id))
+                affected = true;
+        });
+        if (!affected) {
+            pending.upserts.forEach((item, id) => {
+                if (affected)
+                    return;
+                if (byId.has(id))
+                    affected = true;
+                else if (query.selector != null && (0, match_1.default)(item, query.selector))
+                    affected = true;
+            });
+        }
+        if (!affected)
+            return query.items;
+        return (0, incrementalQueryUpdate_1.mergeChangesetIntoResult)(query.items, query.selector, query.options, {
+            upserts: [...pending.upserts.values()],
+            deletes: [...pending.deletes],
+        });
+    }
+    /**
+     * Registers a write's effect locally and notifies every active query it
+     * touches, then returns a function that drops it again once the write
+     * settles.
+     * @param collectionName - The collection the write targets.
+     * @param upserts - Items inserted or updated by the write.
+     * @param deletes - Ids removed by the write.
+     * @returns A function that drops the pending write and re-notifies.
+     */
+    applyPendingWrite(collectionName, upserts, deletes) {
+        if (upserts.length === 0 && deletes.length === 0)
+            return () => { };
+        const affectedIds = new Set([...upserts.map(item => item.id), ...deletes]);
+        const affected = this.affectedQueries(collectionName, upserts, affectedIds);
+        // Captured before the write is registered, so the notification below can say what actually
+        // changed for a reader rather than just that something did.
+        const servedBefore = this.servedResults(collectionName, affected);
+        const seq = this.pendingWriteSeq += 1;
+        const state = this.pendingWrites.get(collectionName)
+            ?? {
+                writes: new Map(),
+                byId: new Map(),
+                flat: { upserts: new Map(), deletes: new Set() },
+                lastChange: null,
+            };
+        const write = {
+            upserts: new Map(upserts.map(item => [item.id, item])),
+            deletes: new Set(deletes),
+        };
+        state.writes.set(seq, write);
+        // Upserts first, then deletes, so a write naming the same id in both ends as a delete — the
+        // order the collapsed view was folded in when it was still rebuilt from scratch.
+        write.upserts.forEach((item, id) => WorkerDataAdapter.pushPendingEntry(state, id, item, seq));
+        write.deletes.forEach(id => WorkerDataAdapter.pushPendingEntry(state, id, null, seq));
+        this.pendingWrites.set(collectionName, state);
+        this.bumpPendingWriteVersion(collectionName);
+        const addedVersion = this.pendingWriteVersions.get(collectionName) ?? 0;
+        state.lastChange = { version: addedVersion, ids: [...affectedIds] };
+        this.notifyWithDeltas(collectionName, affected, servedBefore);
+        return () => {
+            const current = this.pendingWrites.get(collectionName);
+            if (!current)
+                return;
+            const settled = current.writes.get(seq);
+            // Already dropped: settling twice must not take a *later* write's contribution back out.
+            if (!settled)
+                return;
+            const affectedOnDrop = this.affectedQueries(collectionName, upserts, affectedIds);
+            const beforeDrop = this.servedResults(collectionName, affectedOnDrop);
+            current.writes.delete(seq);
+            settled.upserts.forEach((item, id) => WorkerDataAdapter.dropPendingEntry(current, id, seq));
+            settled.deletes.forEach(id => WorkerDataAdapter.dropPendingEntry(current, id, seq));
+            // With nothing left in flight the state is dropped entirely, and a query's served result is
+            // its stored one again — which `computeServedResult` answers without looking at anything.
+            if (current.writes.size === 0)
+                this.pendingWrites.delete(collectionName);
+            this.bumpPendingWriteVersion(collectionName);
+            if (current.writes.size > 0) {
+                const droppedVersion = this.pendingWriteVersions.get(collectionName) ?? 0;
+                current.lastChange = { version: droppedVersion, ids: [...affectedIds] };
+            }
+            // By the time a write settles the host's own answer has usually already landed, so dropping
+            // the optimistic copy changes nothing a reader can see and produces no notification at all.
+            this.notifyWithDeltas(collectionName, affectedOnDrop, beforeDrop);
+        };
+    }
+    // The queries whose result the write can have changed — either because a written item matches
+    // their selector, or because they already hold one of the affected items (an update that moves
+    // an item out of a query, or a removal).
+    affectedQueries(collectionName, upserts, affectedIds) {
+        const affected = [];
+        this.queries[collectionName]?.forEach((query) => {
+            const byId = this.queryItemsById(query);
+            let wasHolding = false;
+            affectedIds.forEach((id) => {
+                if (byId.has(id))
+                    wasHolding = true;
+            });
+            const nowMatches = upserts.some(item => query.selector != null
+                && (0, match_1.default)(item, query.selector));
+            if (!wasHolding && !nowMatches)
+                return;
+            affected.push(query);
+        });
+        return affected;
+    }
+    servedResults(collectionName, queries) {
+        return new Map(queries.map(query => [query, this.servedResult(collectionName, query)]));
+    }
+    // Tells each query what changed for someone reading it, and says nothing to a query where the
+    // answer is the same as before. A reader that has to re-run the query to find that out pays for
+    // the whole result to learn nothing.
+    notifyWithDeltas(collectionName, queries, servedBefore) {
+        queries.forEach((query) => {
+            const before = servedBefore.get(query);
+            if (before == null)
+                return;
+            const delta = (0, queryDelta_1.diffQueryResults)(before, this.servedResult(collectionName, query));
+            if ((0, queryDelta_1.isEmptyQueryDelta)(delta))
+                return;
+            query.stateChangeCallbacks.forEach(callback => (0, queryDelta_1.callWithDelta)(callback, query.state, delta));
+        });
+    }
+    matchObservableItems(collectionName, selector, onlyFirst) {
+        if (selector == null)
+            return [];
+        // `updateOne({ id })` and `removeOne({ id })` are what an application writes most of the time,
+        // and they name exactly the rows they touch — no reason to materialise every active query's
+        // result and run the matcher over all of it to find them.
+        const ids = selectorIds(selector);
+        const matches = ids == null
+            ? this.observableItems(collectionName).filter(item => (0, match_1.default)(item, selector))
+            : this.observableItemsByIds(collectionName, ids);
+        return onlyFirst ? matches.slice(0, 1) : matches;
+    }
+    resolveUpdate(collectionName, selector, modifier, onlyFirst) {
+        const { $setOnInsert, ...restModifier } = modifier;
+        const upserts = [];
+        const deletes = [];
+        this.matchObservableItems(collectionName, selector, onlyFirst).forEach((item) => {
+            const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+            upserts.push(modifiedItem);
+            if (modifiedItem.id !== item.id)
+                deletes.push(item.id);
+        });
+        return { upserts, deletes };
+    }
+    resolveRemoval(collectionName, selector, onlyFirst) {
+        return this.matchObservableItems(collectionName, selector, onlyFirst).map(item => item.id);
+    }
+    resolveReplacement(item, replacement) {
+        const modifiedItem = { ...replacement, id: replacement.id ?? item.id };
+        return {
+            upserts: [modifiedItem],
+            deletes: modifiedItem.id === item.id ? [] : [item.id],
+        };
+    }
+    // Makes a write's effect visible to active queries for the duration of the
+    // round trip, and drops it again once the worker has spoken — see
+    // `pendingWrites`.
+    async withPendingWrite(collectionName, delta, run) {
+        const dropPendingWrite = this.applyPendingWrite(collectionName, delta.upserts, delta.deletes);
+        try {
+            return await run();
+        }
+        finally {
+            dropPendingWrite();
+        }
+    }
+    enqueueBatched(collectionName, method, args) {
+        const helper = this.batchExecutionHelpers.get(collectionName);
+        if (!helper)
+            throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
+        return helper.enqueue(method, args);
+    }
+    // ---------- end batching integration ----------
+    updateQuery(collectionName, query, update) {
+        const id = (0, queryId_1.default)(query.selector, query.options);
+        const collectionQueries = this.queries[collectionName];
+        if (!collectionQueries)
+            return;
+        const existing = collectionQueries.get(id);
+        const newState = {
+            selector: query.selector,
+            options: query.options,
+            state: 'active',
+            error: null,
+            stateChangeCallbacks: [],
+            ...existing,
+            ...update,
+            // An update that says nothing about the items leaves them alone. A query going back to
+            // `'active'` while it is recomputed is exactly that, and letting it blank the result would
+            // leave every reader of this query with nothing to show until the recomputation lands.
+            ...update.items
+                ? { items: update.items, itemsById: undefined }
+                : { items: existing?.items ?? [] },
+        };
+        collectionQueries.set(id, newState);
+        this.queries[collectionName] = collectionQueries;
+    }
+    createCollectionBackend(collection, indices) {
+        this.queries[collection.name] = new Map();
+        this.execInBackground('registerCollection', collection.name, [indices]);
+        this.collectionReady.set(collection.name, this.exec('isReady', collection.name));
+        this.batchExecutionHelpers.set(collection.name, (0, batchOnNextTick_1.default)(async (method, args) => this.exec(method, collection.name, args)));
+        return {
+            insert: async (item) => {
+                return this.withPendingWrite(collection.name, { upserts: [item], deletes: [] }, () => this.enqueueBatched(collection.name, 'insert', [item]));
+            },
+            updateOne: async (selector, modifier) => {
+                return this.withPendingWrite(collection.name, this.resolveUpdate(collection.name, selector, modifier, true), () => this.enqueueBatched(collection.name, 'updateOne', [selector, modifier]));
+            },
+            updateMany: async (selector, modifier) => {
+                return this.withPendingWrite(collection.name, this.resolveUpdate(collection.name, selector, modifier, false), () => this.enqueueBatched(collection.name, 'updateMany', [selector, modifier]));
+            },
+            replaceOne: async (selector, replacement) => {
+                const [item] = this.matchObservableItems(collection.name, selector, true);
+                return this.withPendingWrite(collection.name, item == null
+                    ? { upserts: [], deletes: [] }
+                    : this.resolveReplacement(item, replacement), () => this.enqueueBatched(collection.name, 'replaceOne', [selector, replacement]));
+            },
+            removeOne: async (selector) => {
+                return this.withPendingWrite(collection.name, { upserts: [], deletes: this.resolveRemoval(collection.name, selector, true) }, () => this.enqueueBatched(collection.name, 'removeOne', [selector]));
+            },
+            removeMany: async (selector) => {
+                return this.withPendingWrite(collection.name, { upserts: [], deletes: this.resolveRemoval(collection.name, selector, false) }, () => this.enqueueBatched(collection.name, 'removeMany', [selector]));
+            },
+            // methods for registering and unregistering queries that will be called from the collection during find/findOne
+            registerQuery: (selector, options) => {
+                this.updateQuery(collection.name, { selector, options }, { state: 'active', error: null, items: [] });
+                // A query the worker could not register will never answer. Left as a bare rejection it
+                // would surface as an uncaught error and the cursor would sit on its empty result forever,
+                // indistinguishable from a query with nothing to show; published as an error it reaches
+                // the collection's `query.error` event, which is what that event is for.
+                this.execInBackground('registerQuery', collection.name, [selector, options], (error) => {
+                    const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                    if (!query)
+                        return;
+                    this.updateQuery(collection.name, { selector, options }, { state: 'error', error });
+                    query.stateChangeCallbacks.forEach(callback => callback('error'));
+                });
+            },
+            unregisterQuery: (selector, options) => {
+                this.queries[collection.name]?.delete((0, queryId_1.default)(selector, options));
+                // Nothing holds the query any more, so a failure here has nobody to report to — but it
+                // still must not escape as an uncaught error, which is what a disposed collection would
+                // otherwise produce every time a cursor was cleaned up after it.
+                this.execInBackground('unregisterQuery', collection.name, [selector, options]);
+            },
+            getQueryState: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.state || 'active';
+            },
+            getQueryError: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.error || null;
+            },
+            getQueryResult: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                if (!query)
+                    return [];
+                return this.servedResult(collection.name, query);
+            },
+            onQueryStateChange: (selector, options, callback) => {
+                this.updateQuery(collection.name, { selector, options }, {
+                    stateChangeCallbacks: [
+                        ...this.queries[collection.name]?.get((0, queryId_1.default)(selector, options))?.stateChangeCallbacks || [],
+                        callback,
+                    ],
+                });
+                return () => {
+                    const currentCallbacks = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options))?.stateChangeCallbacks;
+                    if (!currentCallbacks)
+                        return;
+                    this.updateQuery(collection.name, { selector, options }, {
+                        stateChangeCallbacks: currentCallbacks
+                            .filter(existingCallback => existingCallback !== callback),
+                    });
+                };
+            },
+            executeQuery: (selector, options) => this.exec('executeQuery', collection.name, selector, options),
+            // lifecycle methods
+            dispose: async () => {
+                await this.exec('unregisterCollection', collection.name);
+                this.isDisposed = true;
+                this.worker.terminate?.();
+            },
+            // Awaits the promise `createCollectionBackend` already started rather
+            // than asking the worker again. Readiness happens once and never goes
+            // back, so a repeated question can only get the same answer — but it
+            // still cost a full round trip each time, and callers ask often: a
+            // repository helper that awaits `collection.ready()` before touching a
+            // record turns a thousand-record sync into a thousand extra messages.
+            // One app measured 2,273 `isReady` messages in a single session, more
+            // than any other message type it produced.
+            isReady: async () => {
+                await this.collectionReady.get(collection.name);
+            },
+        };
+    }
+}
+exports.default = WorkerDataAdapter;