@signaldb/core 2.0.0-beta.21 → 2.0.0-beta.22

package/dist/index36.mjs

@@ -1,580 +1,433 @@
-import { applyQueryDelta, callWithDelta, canApplyQueryDelta, diffQueryResults, isEmptyQueryDelta } from "./index4.mjs";
-import randomId from "./index9.mjs";
+import { callWithDelta, diffQueryResults, isEmptyQueryDelta } from "./index4.mjs";
 import deepClone from "./index18.mjs";
 import match from "./index19.mjs";
 import modify from "./index20.mjs";
-import { mergeChangesetIntoResult } from "./index25.mjs";
+import incrementalQueryUpdate from "./index25.mjs";
 import queryId from "./index26.mjs";
-import batchOnNextTick from "./index35.mjs";
-//#region src/WorkerDataAdapter.ts
+import executeStorageQuery from "./index35.mjs";
+//#region src/AsyncDataAdapter.ts
 /**
-* 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.
+* Carries the context needed to act on a failed query. The bare storage error
+* on its own does not say which collection or selector produced it, which made
+* the default `console.error` hook close to useless.
 */
-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;
+var QueryError = class extends Error {
+	collectionName;
+	selector;
+	options;
+	attempts;
+	constructor(collectionName, selector, options, attempts, cause) {
+		const reason = cause instanceof Error ? cause.message : String(cause);
+		super(`Query on "${collectionName}" failed after ${attempts} attempt(s): ${reason}`);
+		this.name = "QueryError";
+		this.collectionName = collectionName;
+		this.selector = selector;
+		this.options = options;
+		this.attempts = attempts;
+		this.cause = cause;
+	}
+};
+/**
+* Turns the item states a write produced into the upsert/delete split a query update needs.
+*
+* The two lists are not symmetric: an item that is still there after the write is described by its
+* new state, while an item that is gone — removed, or given a new id — is described by the id it
+* used to have and nothing else. Mixing the states from before and after a write into one list
+* loses exactly that distinction.
+* @template T - The type of the items.
+* @param previousItems - The items as they were before the write.
+* @param modifiedItems - The items as they are after it.
+* @returns The changeset describing the write.
+*/
+function toChangeset(previousItems, modifiedItems) {
+	const modifiedIds = new Set(modifiedItems.map((item) => item.id));
+	return {
+		upserts: modifiedItems,
+		deletes: previousItems.map((item) => item.id).filter((id) => !modifiedIds.has(id))
+	};
 }
-var WorkerDataAdapter = class WorkerDataAdapter {
-	worker;
+var DEFAULT_RETRY_ATTEMPTS = 3;
+var defaultRetryDelay = (attempt) => 100 * 4 ** (attempt - 1);
+var wait = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* AsyncDataAdapter
+* Combines WorkerDataAdapter + WorkerDataAdapterHost into a single, transport-free adapter.
+* - Keeps the DataAdapter/CollectionBackend surface identical to the Worker version.
+* - Executes queries and mutations directly against the provided StorageAdapter.
+* - Preserves index-aware query optimization and push-style query updates to listeners.
+*/
+var AsyncDataAdapter = class {
 	options;
 	id;
-	isDisposed = false;
-	workerReady;
-	log = () => {};
-	collectionReady = /* @__PURE__ */ new Map();
-	batchExecutionHelpers = /* @__PURE__ */ new Map();
-	queries = {};
-	pendingRequests = /* @__PURE__ */ new Map();
-	pendingWrites = /* @__PURE__ */ new Map();
-	pendingWriteSeq = 0;
-	pendingWriteVersions = /* @__PURE__ */ new Map();
-	bumpPendingWriteVersion(collectionName) {
-		const current = this.pendingWriteVersions.get(collectionName) ?? 0;
-		this.pendingWriteVersions.set(collectionName, current + 1);
-	}
-	constructor(worker, options) {
-		this.worker = worker;
+	onError;
+	retryAttempts;
+	retryDelay;
+	storageAdapters = /* @__PURE__ */ new Map();
+	storageAdapterReady = /* @__PURE__ */ new Map();
+	collectionIndices = /* @__PURE__ */ new Map();
+	queries = /* @__PURE__ */ new Map();
+	constructor(options) {
 		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(/* @__PURE__ */ new Error("WorkerDataAdapter initialization timed out"));
-			}, 5e3);
-			this.resolveWorkerReady = () => {
-				clearTimeout(timeoutId);
-				resolve();
-			};
+		this.id = options.id || "async-data-adapter";
+		this.onError = options.onError ?? ((error) => {
+			console.error(error);
 		});
-		this.worker.addEventListener("message", this.handleWorkerMessage);
+		this.retryAttempts = Math.max(1, options.retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS);
+		this.retryDelay = options.retry?.delay ?? defaultRetryDelay;
 	}
-	resolveWorkerReady = () => {};
-	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;
-		const id = qid ?? (selector === void 0 ? void 0 : queryId(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) {
-			const canApply = canApplyQueryDelta(query.items, delta);
-			if (!canApply || 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;
-				settled.stateChangeCallbacks.forEach((callback) => callWithDelta(callback, state, canApply ? delta : void 0));
-				return;
-			}
-			const servedBefore = this.flattenPendingWrites(collectionName) == null ? null : this.servedResult(collectionName, query);
-			nextItems = applyQueryDelta(query.items, delta);
-			if (servedBefore == null) deltaToPublish = delta;
-			else {
-				this.updateQuery(collectionName, {
-					selector: query.selector,
-					options: query.options
-				}, {
-					state,
-					error,
-					items: nextItems
-				});
-				const stored = collectionQueries.get(id);
-				if (!stored) return;
-				const servedDelta = diffQueryResults(servedBefore, this.servedResult(collectionName, stored));
-				if (isEmptyQueryDelta(servedDelta) && state === query.state) return;
-				stored.stateChangeCallbacks.forEach((callback) => callWithDelta(callback, state, servedDelta));
-				return;
+	createCollectionBackend(collection, indices) {
+		this.collectionIndices.set(collection.name, indices);
+		this.queries.set(collection.name, /* @__PURE__ */ new Map());
+		this.ensureStorageAdapter(collection.name);
+		const ready = (async () => {
+			try {
+				await this.setupStorage(collection.name, indices);
+			} catch (error) {
+				this.onError(error);
+				throw error;
 			}
-		}
-		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) => 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 = randomId();
-			this.pendingRequests.set(messageId, {
-				resolve,
-				reject
+		})();
+		this.storageAdapterReady.set(collection.name, ready);
+		const registerQuery = (selector, options) => {
+			const qid = queryId(selector, options);
+			const registry = this.queries.get(collection.name);
+			if (!registry) throw new Error(`Collection ${collection.name} not initialized!`);
+			registry.set(qid, {
+				selector,
+				options,
+				items: [],
+				listeners: /* @__PURE__ */ new Set(),
+				...registry.get(qid),
+				state: "active",
+				error: null
 			});
-			this.worker.postMessage({
-				id: messageId,
-				workerId: this.id,
-				method,
-				args: [collectionName, ...args]
+			this.fulfillQuery(collection.name, selector, options).catch(this.onError);
+		};
+		const unregisterQuery = (selector, options) => {
+			const qid = queryId(selector, options);
+			this.queries.get(collection.name)?.delete(qid);
+		};
+		const getQueryState = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(queryId(selector, options)))?.state ?? "active";
+		};
+		const getQueryError = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(queryId(selector, options)))?.error ?? null;
+		};
+		const getQueryResult = (selector, options) => {
+			return (this.queries.get(collection.name)?.get(queryId(selector, options)))?.items ?? [];
+		};
+		const retryQuery = (selector, options) => {
+			const qid = queryId(selector, options);
+			if (!this.queries.get(collection.name)?.get(qid)) return;
+			this.publishState(collection.name, qid, "active", null);
+			this.runQuery(collection.name, selector, options);
+		};
+		const onQueryStateChange = (selector, options, callback) => {
+			const qid = queryId(selector, options);
+			const registry = this.queries.get(collection.name);
+			if (!registry) throw new Error(`Collection ${collection.name} not initialized!`);
+			if (!registry.has(qid)) registry.set(qid, {
+				selector,
+				options,
+				state: "active",
+				error: null,
+				items: [],
+				listeners: /* @__PURE__ */ new Set()
 			});
-		});
-	}
-	/**
-	* 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;
+			registry.get(qid)?.listeners.add(callback);
+			if (registry.get(qid)?.state === "error") retryQuery(selector, options);
+			return () => registry.get(qid)?.listeners.delete(callback);
+		};
+		return {
+			insert: async (item) => {
+				await ready;
+				return await this.insert(collection.name, item);
+			},
+			updateOne: async (selector, modifier) => {
+				await ready;
+				return this.updateOne(collection.name, selector, modifier);
+			},
+			updateMany: async (selector, modifier) => {
+				await ready;
+				return this.updateMany(collection.name, selector, modifier);
+			},
+			replaceOne: async (selector, replacement) => {
+				await ready;
+				return this.replaceOne(collection.name, selector, replacement);
+			},
+			removeOne: async (selector) => {
+				await ready;
+				return this.removeOne(collection.name, selector);
+			},
+			removeMany: async (selector) => {
+				await ready;
+				return this.removeMany(collection.name, selector);
+			},
+			registerQuery,
+			unregisterQuery,
+			retryQuery,
+			getQueryState,
+			getQueryError,
+			getQueryResult,
+			onQueryStateChange,
+			executeQuery: async (selector, options) => {
+				await ready;
+				return this.executeQuery(collection.name, selector, options);
+			},
+			dispose: async () => {
+				this.storageAdapters.delete(collection.name);
+				this.queries.delete(collection.name);
+				this.collectionIndices.delete(collection.name);
+				this.storageAdapterReady.delete(collection.name);
+			},
+			isReady: async () => {
+				await ready;
 			}
-			this.log(method, "failed", error);
-		});
-	}
-	queryItemsById(query) {
-		if (!query.itemsById) query.itemsById = new Map(query.items.map((item) => [item.id, item]));
-		return query.itemsById;
-	}
-	flattenPendingWrites(collectionName) {
-		const state = this.pendingWrites.get(collectionName);
-		if (!state || state.writes.size === 0) return null;
-		return state.flat;
-	}
-	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);
-	}
-	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);
+	async setupStorage(collectionName, indices) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		await storage.setup();
+		await Promise.all(indices.map((index) => storage.createIndex(index)));
 	}
-	static providesFullItems(query) {
-		return query.options?.fields == null;
+	ensureStorageAdapter(name) {
+		if (this.storageAdapters.has(name)) return;
+		const adapter = this.options.storage(name);
+		if (!adapter) return;
+		this.storageAdapters.set(name, adapter);
 	}
-	observableItems(collectionName) {
-		const byId = /* @__PURE__ */ 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()];
+	/**
+	* Compute and publish the result for a specific query
+	* @param collectionName - name of the collection
+	* @param selector - query selector
+	* @param options - query options
+	*/
+	async fulfillQuery(collectionName, selector, options) {
+		const qid = queryId(selector, options);
+		const registry = this.queries.get(collectionName);
+		if (!registry) throw new Error(`Collection ${collectionName} not initialized!`);
+		if (!registry.get(qid)) return;
+		this.publishState(collectionName, qid, "active", null);
+		await this.runQuery(collectionName, selector, options);
 	}
-	observableItemsByIds(collectionName, ids) {
-		const pending = this.flattenPendingWrites(collectionName);
-		const found = /* @__PURE__ */ new Map();
-		ids.forEach((id) => {
-			if (pending?.deletes.has(id)) return;
-			const pendingItem = pending?.upserts.get(id);
-			if (pendingItem) {
-				found.set(id, pendingItem);
+	/**
+	* Executes a query, retrying transient failures before giving up. The state
+	* stays `'active'` across retries — consumers should see "still loading",
+	* not "failed", until we actually stop trying. Only the final failure is
+	* published as `'error'` and reported through `onError`; previously that
+	* error was swallowed entirely (`fulfillQuery` caught it internally, so the
+	* `.catch(this.onError)` on its call site was unreachable) and the query
+	* stayed dead for the rest of the session.
+	* @param collectionName - name of the collection
+	* @param selector - query selector
+	* @param options - query options
+	*/
+	async runQuery(collectionName, selector, options) {
+		const qid = queryId(selector, options);
+		let lastError;
+		for (let attempt = 1; attempt <= this.retryAttempts; attempt += 1) {
+			if (!this.queries.get(collectionName)?.has(qid)) return;
+			try {
+				const items = await this.executeQuery(collectionName, selector, options);
+				const rec = this.queries.get(collectionName)?.get(qid);
+				const delta = rec?.answered ? diffQueryResults(rec.items, items) : void 0;
+				this.publishResult(collectionName, qid, items);
+				this.publishState(collectionName, qid, "complete", null, delta);
 				return;
+			} catch (error) {
+				lastError = error;
+				if (attempt < this.retryAttempts) await wait(this.retryDelay(attempt));
 			}
-			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()];
+		}
+		const queryError = new QueryError(collectionName, selector, options, this.retryAttempts, lastError);
+		this.publishState(collectionName, qid, "error", queryError);
+		this.onError(queryError);
 	}
-	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;
+	/**
+	* Notify listeners about state changes and keep the cache updated
+	* @param collectionName - name of the collection
+	* @param qid - query id
+	* @param state - new state
+	* @param error - error if state is 'error', null otherwise
+	* @param delta - what changed about the result, when that is known
+	*/
+	publishState(collectionName, qid, state, error, delta) {
+		const rec = this.queries.get(collectionName)?.get(qid);
+		if (!rec) return;
+		rec.state = state;
+		rec.error = error;
+		const subscribers = [...rec.listeners];
+		for (const callback of subscribers) try {
+			callWithDelta(callback, state, delta);
+		} catch (error_) {
+			this.onError(error_);
+		}
 	}
-	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 mergeChangesetIntoResult(served.items, query.selector, query.options, this.changesetForIds(collectionName, query, state.lastChange.ids));
+	publishResult(collectionName, qid, items) {
+		const rec = this.queries.get(collectionName)?.get(qid);
+		if (!rec) return;
+		rec.items = items;
+		rec.itemIds = void 0;
+		rec.answered = true;
 	}
-	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 && match(item, query.selector)) affected = true;
-		});
-		if (!affected) return query.items;
-		return mergeChangesetIntoResult(query.items, query.selector, query.options, {
-			upserts: [...pending.upserts.values()],
-			deletes: [...pending.deletes]
-		});
+	queryItemIds(rec) {
+		if (!rec.itemIds) rec.itemIds = new Set(rec.items.map((item) => item.id));
+		return rec.itemIds;
 	}
 	/**
-	* 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.
+	* Reads one query's result from the storage adapter.
+	*
+	* The work lives in `executeStorageQuery` because this method used to exist
+	* three times over — here, in `AutoFetchDataAdapter` and in
+	* `WorkerDataAdapterHost` — as the same eight lines, which is how a storage
+	* adapter capability ends up honoured by one adapter and silently ignored by
+	* the others.
+	* @template T - The type of the items.
+	* @template I - The type of the item ids.
+	* @param collectionName - The collection to read from.
+	* @param selector - The query's selector.
+	* @param options - The query's sort, window and projection.
+	* @returns The query result.
 	*/
-	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);
-		const servedBefore = this.servedResults(collectionName, affected);
-		const seq = this.pendingWriteSeq += 1;
-		const state = this.pendingWrites.get(collectionName) ?? {
-			writes: /* @__PURE__ */ new Map(),
-			byId: /* @__PURE__ */ new Map(),
-			flat: {
-				upserts: /* @__PURE__ */ new Map(),
-				deletes: /* @__PURE__ */ new Set()
-			},
-			lastChange: null
-		};
-		const write = {
-			upserts: new Map(upserts.map((item) => [item.id, item])),
-			deletes: new Set(deletes)
-		};
-		state.writes.set(seq, write);
-		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);
-		state.lastChange = {
-			version: this.pendingWriteVersions.get(collectionName) ?? 0,
-			ids: [...affectedIds]
-		};
-		this.notifyWithDeltas(collectionName, affected, servedBefore);
-		return () => {
-			const current = this.pendingWrites.get(collectionName);
-			if (!current) return;
-			const settled = current.writes.get(seq);
-			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));
-			if (current.writes.size === 0) this.pendingWrites.delete(collectionName);
-			this.bumpPendingWriteVersion(collectionName);
-			if (current.writes.size > 0) current.lastChange = {
-				version: this.pendingWriteVersions.get(collectionName) ?? 0,
-				ids: [...affectedIds]
-			};
-			this.notifyWithDeltas(collectionName, affectedOnDrop, beforeDrop);
-		};
+	async executeQuery(collectionName, selector, options) {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No storage adapter for collection ${collectionName}`);
+		return executeStorageQuery(storageAdapter, this.collectionIndices.get(collectionName) ?? [], selector, options);
 	}
-	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 && match(item, query.selector));
-			if (!wasHolding && !nowMatches) return;
-			affected.push(query);
+	/**
+	* After mutations, bring every affected active query up to date.
+	*
+	* A query whose previous result is enough to answer the change is brought up to date from that
+	* result alone — no round trip to the storage, and no detour through `'active'`, because there is
+	* no window in which the query is stale. Only a query the change cannot be reasoned about
+	* locally — a window onto a larger set, or one that has never been answered — goes back to the
+	* store, and that one gets the same retry and reporting behaviour a freshly registered query
+	* gets: a refresh that fails silently leaves exactly the same dead cursor.
+	* @param collectionName - name of the collection
+	* @param changes - the items the write created, updated or removed
+	*/
+	async checkQueryUpdates(collectionName, changes) {
+		const registry = this.queries.get(collectionName);
+		if (!registry) throw new Error(`Collection ${collectionName} not initialized!`);
+		if (registry.size === 0) return;
+		if (changes.upserts.length === 0 && changes.deletes.length === 0) return;
+		const affected = [...registry.values()].filter((rec) => {
+			const ids = this.queryItemIds(rec);
+			if (changes.deletes.some((id) => ids.has(id))) return true;
+			return changes.upserts.some((item) => ids.has(item.id) || match(item, rec.selector));
 		});
-		return affected;
-	}
-	servedResults(collectionName, queries) {
-		return new Map(queries.map((query) => [query, this.servedResult(collectionName, query)]));
+		if (affected.length === 0) return;
+		const needsReExecution = [];
+		for (const rec of affected) {
+			const { selector, options } = rec;
+			const incremental = rec.answered ? incrementalQueryUpdate(rec.items, selector, options, changes) : null;
+			if (incremental == null) {
+				needsReExecution.push(rec);
+				continue;
+			}
+			const qid = queryId(selector, options);
+			const delta = diffQueryResults(rec.items, incremental);
+			if (isEmptyQueryDelta(delta)) continue;
+			this.publishResult(collectionName, qid, incremental);
+			this.publishState(collectionName, qid, "complete", null, delta);
+		}
+		for (const { selector, options } of needsReExecution) this.publishState(collectionName, queryId(selector, options), "active", null);
+		await Promise.all(needsReExecution.map(({ selector, options }) => this.runQuery(collectionName, selector, options)));
 	}
-	notifyWithDeltas(collectionName, queries, servedBefore) {
-		queries.forEach((query) => {
-			const before = servedBefore.get(query);
-			if (before == null) return;
-			const delta = diffQueryResults(before, this.servedResult(collectionName, query));
-			if (isEmptyQueryDelta(delta)) return;
-			query.stateChangeCallbacks.forEach((callback) => callWithDelta(callback, query.state, delta));
+	async insert(collectionName, newItem) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		if ((await storage.readIds([newItem.id])).length > 0) throw new Error(`Item with id ${String(newItem.id)} already exists`);
+		await storage.insert([newItem]);
+		await this.checkQueryUpdates(collectionName, {
+			upserts: [newItem],
+			deletes: []
 		});
+		return newItem;
 	}
-	matchObservableItems(collectionName, selector, onlyFirst) {
-		if (selector == null) return [];
-		const ids = selectorIds(selector);
-		const matches = ids == null ? this.observableItems(collectionName).filter((item) => match(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 = modify(deepClone(item), restModifier);
-			upserts.push(modifiedItem);
-			if (modifiedItem.id !== item.id) deletes.push(item.id);
-		});
+	async updateOne(collectionName, selector, modifier) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
+		const { $setOnInsert, ...rest } = modifier;
+		if (item == null) return [];
+		const modified = modify(deepClone(item), rest);
+		if (item.id !== modified.id) {
+			if ((await storage.readIds([modified.id])).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		}
+		await storage.replace([modified]);
+		await this.checkQueryUpdates(collectionName, toChangeset([item], [modified]));
 		return {
-			upserts,
-			deletes
+			items: [modified],
+			previousItems: [item]
 		};
 	}
-	resolveRemoval(collectionName, selector, onlyFirst) {
-		return this.matchObservableItems(collectionName, selector, onlyFirst).map((item) => item.id);
+	async updateMany(collectionName, selector, modifier) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const items = await this.executeQuery(collectionName, selector);
+		if (items.length === 0) return [];
+		const { $setOnInsert, ...rest } = modifier;
+		const changed = await Promise.all(items.map(async (item) => {
+			const modified = modify(deepClone(item), rest);
+			if (item.id !== modified.id) {
+				if ((await storage.readIds([modified.id])).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+			}
+			return modified;
+		}));
+		await storage.replace(changed);
+		await this.checkQueryUpdates(collectionName, toChangeset(items, changed));
+		return {
+			items: changed,
+			previousItems: items
+		};
 	}
-	resolveReplacement(item, replacement) {
-		const modifiedItem = {
+	async replaceOne(collectionName, selector, replacement) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
+		if (item == null) return [];
+		const modified = {
 			...replacement,
 			id: replacement.id ?? item.id
 		};
+		if (item.id !== modified.id) {
+			if ((await storage.readIds([modified.id])).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		}
+		await storage.replace([modified]);
+		await this.checkQueryUpdates(collectionName, toChangeset([item], [modified]));
 		return {
-			upserts: [modifiedItem],
-			deletes: modifiedItem.id === item.id ? [] : [item.id]
+			items: [modified],
+			previousItems: [item]
 		};
 	}
-	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);
-	}
-	updateQuery(collectionName, query, update) {
-		const id = queryId(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,
-			...update.items ? {
-				items: update.items,
-				itemsById: void 0
-			} : { items: existing?.items ?? [] }
-		};
-		collectionQueries.set(id, newState);
-		this.queries[collectionName] = collectionQueries;
+	async removeOne(collectionName, selector) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
+		if (item == null) return [];
+		await storage.remove([item]);
+		await this.checkQueryUpdates(collectionName, {
+			upserts: [],
+			deletes: [item.id]
+		});
+		return [item];
 	}
-	createCollectionBackend(collection, indices) {
-		this.queries[collection.name] = /* @__PURE__ */ new Map();
-		this.execInBackground("registerCollection", collection.name, [indices]);
-		this.collectionReady.set(collection.name, this.exec("isReady", collection.name));
-		this.batchExecutionHelpers.set(collection.name, batchOnNextTick(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]));
-			},
-			registerQuery: (selector, options) => {
-				this.updateQuery(collection.name, {
-					selector,
-					options
-				}, {
-					state: "active",
-					error: null,
-					items: []
-				});
-				this.execInBackground("registerQuery", collection.name, [selector, options], (error) => {
-					const query = this.queries[collection.name]?.get(queryId(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(queryId(selector, options));
-				this.execInBackground("unregisterQuery", collection.name, [selector, options]);
-			},
-			getQueryState: (selector, options) => {
-				return (this.queries[collection.name]?.get(queryId(selector, options)))?.state || "active";
-			},
-			getQueryError: (selector, options) => {
-				return (this.queries[collection.name]?.get(queryId(selector, options)))?.error || null;
-			},
-			getQueryResult: (selector, options) => {
-				const query = this.queries[collection.name]?.get(queryId(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(queryId(selector, options))?.stateChangeCallbacks || [], callback] });
-				return () => {
-					const currentCallbacks = this.queries[collection.name]?.get(queryId(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),
-			dispose: async () => {
-				await this.exec("unregisterCollection", collection.name);
-				this.isDisposed = true;
-				this.worker.terminate?.();
-			},
-			isReady: async () => {
-				await this.collectionReady.get(collection.name);
-			}
-		};
+	async removeMany(collectionName, selector) {
+		const storage = this.storageAdapters.get(collectionName);
+		if (!storage) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const items = await this.executeQuery(collectionName, selector);
+		if (items.length === 0) return [];
+		await storage.remove(items);
+		await this.checkQueryUpdates(collectionName, {
+			upserts: [],
+			deletes: items.map((item) => item.id)
+		});
+		return items;
 	}
 };
 //#endregion
-export { WorkerDataAdapter as default };
+export { QueryError, AsyncDataAdapter as default };