@signaldb/core 2.0.0-beta.17 → 2.0.0-beta.19

package/dist/index36.mjs

@@ -1,389 +1,580 @@
-import isEqual from "./index2.mjs";
-import { diffQueryResults, isEmptyQueryDelta } from "./index4.mjs";
-import getMatchingKeys from "./index14.mjs";
-import getIndexInfo from "./index17.mjs";
+import { applyQueryDelta, callWithDelta, canApplyQueryDelta, diffQueryResults, isEmptyQueryDelta } from "./index4.mjs";
+import randomId from "./index9.mjs";
 import deepClone from "./index18.mjs";
 import match from "./index19.mjs";
 import modify from "./index20.mjs";
-import projectItems from "./index23.mjs";
-import sortItems from "./index24.mjs";
-import incrementalQueryUpdate from "./index25.mjs";
+import { mergeChangesetIntoResult } from "./index25.mjs";
 import queryId from "./index26.mjs";
-import compact from "./index35.mjs";
-//#region src/WorkerDataAdapterHost.ts
+import batchOnNextTick from "./index35.mjs";
+//#region src/WorkerDataAdapter.ts
 /**
-* 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.
+* 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 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))
-	};
+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 WorkerDataAdapterHost = class {
-	workerContext;
+var WorkerDataAdapter = class WorkerDataAdapter {
+	worker;
 	options;
 	id;
+	isDisposed = false;
+	workerReady;
 	log = () => {};
-	storageAdapters = /* @__PURE__ */ new Map();
-	storageAdapterReady = /* @__PURE__ */ new Map();
-	collectionIndices = /* @__PURE__ */ new Map();
-	queries = /* @__PURE__ */ new Map();
-	onError = (error) => {
-		console.error(error);
-	};
-	constructor(workerContext, options) {
-		this.workerContext = workerContext;
+	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;
 		this.options = options;
 		this.id = this.options.id || "default-worker-data-adapter";
-		if (this.options.onError) this.onError = this.options.onError;
 		if (this.options.log) this.log = this.options.log;
-		this.workerContext.addEventListener("message", async (event) => {
-			try {
-				const { workerId, id, method, args } = event.data;
-				await this.handleMessage(workerId, id, method, args);
-			} catch (error) {
-				this.onError(error);
-			}
-		});
-		this.respond("ready", null, null, "ready");
-	}
-	respond(id, data, error = null, type = "response") {
-		this.workerContext.postMessage({
-			id,
-			workerId: this.id,
-			type,
-			data,
-			error
+		this.workerReady = new Promise((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("WorkerDataAdapter initialization timed out"));
+			}, 5e3);
+			this.resolveWorkerReady = () => {
+				clearTimeout(timeoutId);
+				resolve();
+			};
 		});
+		this.worker.addEventListener("message", this.handleWorkerMessage);
 	}
-	async handleMessage(workerId, id, method, args) {
-		if (workerId !== this.id) return;
-		const fn = this[method];
-		if (typeof fn !== "function") {
-			this.respond(id, null, /* @__PURE__ */ new Error(`Method ${method} not found`));
+	resolveWorkerReady = () => {};
+	handleWorkerMessage = (event) => {
+		const message = event.data;
+		if (message == null) return;
+		if (message.workerId !== this.id) return;
+		if (message.type === "ready") {
+			this.resolveWorkerReady();
 			return;
 		}
-		this.log(method, ...args);
-		await this.isReady(args[0]);
-		try {
-			const result = await fn.apply(this, args);
-			this.respond(id, result);
-		} catch (error) {
-			this.respond(id, null, error);
+		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;
 		}
-	}
-	async getIndexInfo(collectionName, selector) {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		if (selector != null && Object.keys(selector).length === 1 && "id" in selector && typeof selector.id !== "object") return {
-			matched: true,
-			ids: compact([selector.id]),
-			optimizedSelector: {}
-		};
-		if (selector == null) return {
-			matched: false,
-			ids: [],
-			optimizedSelector: {}
-		};
-		return getIndexInfo((this.collectionIndices.get(collectionName) ?? []).map((field) => async (flatSelector) => {
-			if (!Object.hasOwnProperty.call(flatSelector, field)) return { matched: false };
-			const index = await storageAdapter.readIndex(field);
-			const fieldSelector = flatSelector[field];
-			const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
-			const keys = filteresForNull ? {
-				include: null,
-				exclude: [...index.keys()].filter((key) => key != null)
-			} : getMatchingKeys(field, flatSelector);
-			if (keys.include == null && keys.exclude == null) return { matched: false };
-			let includedIds = [];
-			if (keys.include == null) for (const set of index.values()) for (const pos of set) includedIds.push(pos);
-			else for (const key of keys.include) {
-				const idSet = index.get(key);
-				if (idSet) for (const id of idSet) includedIds.push(id);
+		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;
 			}
-			if (keys.exclude != null) {
-				const excludeIds = /* @__PURE__ */ new Set();
-				for (const key of keys.exclude) {
-					const idSet = index.get(key);
-					if (idSet) for (const id of idSet) excludeIds.add(id);
-				}
-				includedIds = includedIds.filter((pos) => !excludeIds.has(pos));
+			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;
 			}
-			return {
-				matched: true,
-				ids: includedIds,
-				fields: [field],
-				keepSelector: filteresForNull
-			};
-		}), selector);
+		}
+		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 queryItems(collectionName, selector) {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const indexInfo = await this.getIndexInfo(collectionName, selector);
-		const matchItems = (item) => {
-			if (indexInfo.optimizedSelector == null) return true;
-			if (Object.keys(indexInfo.optimizedSelector).length <= 0) return true;
-			return match(item, indexInfo.optimizedSelector);
-		};
-		if (indexInfo.matched) {
-			const items = await storageAdapter.readIds(indexInfo.ids);
-			if (isEqual(indexInfo.optimizedSelector, {})) return items;
-			return items.filter(matchItems);
-		} else {
-			const allItems = await storageAdapter.readAll();
-			if (isEqual(selector, {})) return allItems;
-			return allItems.filter(matchItems);
+	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.worker.postMessage({
+				id: messageId,
+				workerId: this.id,
+				method,
+				args: [collectionName, ...args]
+			});
+		});
 	}
-	async executeQuery(collectionName, selector, options) {
-		if (selector === null) return [];
-		const items = await this.queryItems(collectionName, selector || {});
-		const { sort, skip, limit, fields } = options || {};
-		const sorted = sort ? sortItems(items, sort) : items;
-		const skipped = skip ? sorted.slice(skip) : sorted;
-		return projectItems(limit ? skipped.slice(0, limit) : skipped, fields);
+	/**
+	* 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);
+		});
 	}
-	ensureQuery(collectionName, selector, options) {
-		const id = queryId(selector, options);
-		if (!this.queries.get(collectionName)) throw new Error(`Collection ${collectionName} not initialized!`);
-		let query = this.queries.get(collectionName)?.get(id);
-		if (!query) {
-			query = {
-				selector,
-				options,
-				items: null
-			};
-			this.queries.get(collectionName)?.set(id, query);
+	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;
 		}
-		return query;
+		WorkerDataAdapter.writeFlatEntry(state, id, top.item);
 	}
-	setQueryItems(query, items) {
-		query.items = items;
-		query.itemIds = void 0;
+	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);
 	}
-	queryItemIds(query) {
-		if (!query.itemIds) query.itemIds = new Set((query.items ?? []).map((item) => item.id));
-		return query.itemIds;
+	static providesFullItems(query) {
+		return query.options?.fields == null;
 	}
-	emitQueryUpdate(collectionName, selector, options, state, error, items, delta) {
-		const id = queryId(selector, options);
-		if (!this.queries.get(collectionName)) throw new Error(`Collection ${collectionName} not initialized!`);
-		this.respond(id, {
-			collectionName,
-			qid: id,
-			selector,
-			options,
-			state,
-			error,
+	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()];
+	}
+	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);
+				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()];
+	}
+	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,
-			delta
-		}, null, "queryUpdate");
+			fromItems: query.items,
+			pendingVersion
+		};
+		return items;
 	}
-	ensureStorageAdapter(name) {
-		if (this.storageAdapters.has(name)) return;
-		const adapter = this.options.storage(name);
-		if (!adapter) return;
-		this.storageAdapters.set(name, adapter);
+	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));
 	}
-	async checkQueryUpdates(collectionName, changes) {
-		const queries = this.queries.get(collectionName);
-		if (!queries) throw new Error(`Collection ${collectionName} not initialized!`);
-		if (changes.upserts.length === 0 && changes.deletes.length === 0) return;
-		const affectedQueries = [...queries.values()].filter((query) => {
-			const ids = this.queryItemIds(query);
-			if (changes.deletes.some((id) => ids.has(id))) return true;
-			return changes.upserts.some((item) => ids.has(item.id) || match(item, query.selector));
-		});
-		if (affectedQueries.length === 0) return;
-		await Promise.all(affectedQueries.map(async (query) => {
-			const { selector, options } = query;
-			const previous = query.items;
-			const incremental = previous == null ? null : incrementalQueryUpdate(previous, selector, options, changes);
-			if (incremental != null) {
-				const delta = diffQueryResults(previous, incremental);
-				if (isEmptyQueryDelta(delta)) return;
-				this.setQueryItems(query, incremental);
-				this.emitQueryUpdate(collectionName, selector, options, "complete", null, void 0, delta);
+	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;
 			}
-			this.emitQueryUpdate(collectionName, selector, options, "active", null);
-			const queryItems = await this.executeQuery(collectionName, selector, options);
-			if (previous == null) {
-				this.setQueryItems(query, queryItems);
-				this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
+			if (pending?.deletes.has(id)) {
+				deletes.push(id);
 				return;
 			}
-			const delta = diffQueryResults(previous, queryItems);
-			this.setQueryItems(query, queryItems);
-			this.emitQueryUpdate(collectionName, selector, options, "complete", null, void 0, delta);
-		}));
+			const storedItem = stored.get(id);
+			if (storedItem) upserts.push(storedItem);
+			else deletes.push(id);
+		});
+		return {
+			upserts,
+			deletes
+		};
 	}
-	registerCollection = async (collectionName, indices) => {
-		this.collectionIndices.set(collectionName, indices);
-		this.queries.set(collectionName, /* @__PURE__ */ new Map());
-		this.ensureStorageAdapter(collectionName);
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const setupPromise = (async () => {
-			await storageAdapter.setup();
-			await Promise.all(indices.map((index) => storageAdapter.createIndex(index)));
-		})();
-		this.storageAdapterReady.set(collectionName, setupPromise);
-		await setupPromise;
-	};
-	unregisterCollection = async (collectionName) => {
-		this.storageAdapters.delete(collectionName);
-		this.queries.delete(collectionName);
-	};
-	registerQuery = async (collectionName, selector, options) => {
-		const query = this.ensureQuery(collectionName, selector, options);
-		const queryItems = await this.executeQuery(collectionName, selector, options);
-		this.setQueryItems(query, queryItems);
-		this.emitQueryUpdate(collectionName, selector, options, "complete", null, queryItems);
-	};
-	unregisterQuery = async (collectionName, selector, options) => {
-		const id = queryId(selector, options);
-		if (!this.queries.get(collectionName)) throw new Error(`Collection ${collectionName} not initialized!`);
-		this.queries.get(collectionName)?.delete(id);
-	};
-	insert = async (collectionName, input) => {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map((i) => i[0].id) } });
-		const result = input.map(([item]) => {
-			if (item.id == null) return /* @__PURE__ */ new Error("Item must have an id");
-			if (existingItems.some((existing) => existing.id === item.id)) return /* @__PURE__ */ new Error(`Item with id ${item.id} already exists`);
-			return item;
+	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;
 		});
-		const newItems = result.filter((item) => !(item instanceof Error));
-		await storageAdapter.insert(newItems);
-		await this.checkQueryUpdates(collectionName, {
-			upserts: newItems,
-			deletes: []
+		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;
 		});
-		return result;
-	};
-	updateOne = async (collectionName, parameters) => {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const previousItems = [];
-		const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
-			const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-			const { $setOnInsert, ...restModifier } = modifier;
-			if (item == null) return [];
-			previousItems.push(item);
-			const modifiedItem = modify(deepClone(item), restModifier);
-			if (item.id !== modifiedItem.id) {
-				if ((await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 })).length > 0) return /* @__PURE__ */ new Error(`Item with id ${modifiedItem.id} already exists`);
-			}
-			return [modifiedItem];
-		}));
-		const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
-		if (modifiedItems.length > 0) {
-			await storageAdapter.replace(modifiedItems);
-			await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
-		}
-		return result;
-	};
-	updateMany = async (collectionName, parameters) => {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const previousItems = [];
-		const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
-			const items = await this.executeQuery(collectionName, selector);
-			if (items.length === 0) return [];
-			const { $setOnInsert, ...restModifier } = modifier;
-			try {
-				return await Promise.all(items.map(async (item) => {
-					const modifiedItem = modify(deepClone(item), restModifier);
-					if (item.id !== modifiedItem.id) {
-						if ((await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${modifiedItem.id} already exists`);
-					}
-					previousItems.push(item);
-					return modifiedItem;
-				}));
-			} catch (error) {
-				return error;
-			}
-		}));
-		const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
-		if (modifiedItems.length > 0) {
-			await storageAdapter.replace(modifiedItems);
-			await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
-		}
-		return result;
-	};
-	replaceOne = async (collectionName, parameters) => {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const previousItems = [];
-		const result = await Promise.all(parameters.map(async ([selector, replacement]) => {
-			const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-			if (item == null) return [];
-			previousItems.push(item);
-			const modifiedItem = {
-				...replacement,
-				id: replacement.id ?? item.id
+		if (!affected) return query.items;
+		return 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);
+		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]
 			};
-			if (item.id !== modifiedItem.id) {
-				if ((await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 })).length > 0) return /* @__PURE__ */ new Error(`Item with id ${modifiedItem.id} already exists`);
-			}
-			return [modifiedItem];
-		}));
-		const modifiedItems = compact(result.filter((item) => !(item instanceof Error)).flat());
-		if (modifiedItems.length > 0) {
-			await storageAdapter.replace(modifiedItems);
-			await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
-		}
-		return result;
-	};
-	removeOne = async (collectionName, selectors) => {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const result = await Promise.all(selectors.map(async ([selector]) => {
-			const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then((items) => items[0] ?? null);
-			if (item == null) return [];
-			return [item];
-		}));
-		const items = result.flat();
-		if (items.length > 0) {
-			await storageAdapter.remove(items);
-			await this.checkQueryUpdates(collectionName, {
-				upserts: [],
-				deletes: items.map((item) => item.id)
-			});
-		}
-		return result;
-	};
-	removeMany = async (collectionName, selectors) => {
-		const storageAdapter = this.storageAdapters.get(collectionName);
-		if (!storageAdapter) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const result = await Promise.all(selectors.map(async ([selector]) => this.executeQuery(collectionName, selector)));
-		const items = result.flat();
-		if (items.length > 0) {
-			await storageAdapter.remove(items);
-			await this.checkQueryUpdates(collectionName, {
-				upserts: [],
-				deletes: items.map((item) => item.id)
+			this.notifyWithDeltas(collectionName, affectedOnDrop, beforeDrop);
+		};
+	}
+	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);
+		});
+		return affected;
+	}
+	servedResults(collectionName, queries) {
+		return new Map(queries.map((query) => [query, this.servedResult(collectionName, query)]));
+	}
+	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));
+		});
+	}
+	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);
+		});
+		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]
+		};
+	}
+	async withPendingWrite(collectionName, delta, run) {
+		const dropPendingWrite = this.applyPendingWrite(collectionName, delta.upserts, delta.deletes);
+		try {
+			return await run();
+		} finally {
+			dropPendingWrite();
 		}
-		return result;
-	};
-	isReady = async (collectionName) => {
-		return this.storageAdapterReady.get(collectionName);
-	};
+	}
+	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;
+	}
+	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);
+			}
+		};
+	}
 };
 //#endregion
-export { WorkerDataAdapterHost as default };
+export { WorkerDataAdapter as default };