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

package/dist/index39.cjs.js

@@ -1,513 +1,348 @@
-const require_isEqual = require("./index2.cjs.js");
-const require_getIndexInfo = require("./index17.cjs.js");
+const require_queryDelta = require("./index4.cjs.js");
 const require_deepClone = require("./index18.cjs.js");
 const require_match = require("./index19.cjs.js");
 const require_modify = require("./index20.cjs.js");
-const require_project = require("./index22.cjs.js");
-const require_sortItems = require("./index24.cjs.js");
+const require_incrementalQueryUpdate = require("./index25.cjs.js");
 const require_queryId = require("./index26.cjs.js");
-const require_idIndexQuery = require("./index27.cjs.js");
-const require_storageIndexQuery = require("./index33.cjs.js");
-//#region src/AutoFetchDataAdapter.ts
+const require_compact = require("./index33.cjs.js");
+const require_executeStorageQuery = require("./index35.cjs.js");
+//#region src/WorkerDataAdapterHost.ts
 /**
-* Default merge strategy: shallow spread (right wins)
-* @param a first item
-* @param b second item
-* @returns merged item
+* 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 defaultMergeItems(a, b) {
+function toChangeset(previousItems, modifiedItems) {
+	const modifiedIds = new Set(modifiedItems.map((item) => item.id));
 	return {
-		...a,
-		...b
+		upserts: modifiedItems,
+		deletes: previousItems.map((item) => item.id).filter((id) => !modifiedIds.has(id))
 	};
 }
-/**
-* Generates a stable key for a selector
-* @param selector - the selector
-* @returns the key
-*/
-function selectorId(selector) {
-	return JSON.stringify(selector ?? {});
-}
-/**
-* AutoFetchDataAdapter
-*
-* A DataAdapter that:
-* - Mirrors the CollectionBackend surface (CRUD + query registry + lifecycle)
-* - Executes queries against a provided StorageAdapter (local cache)
-* - On first registration of a selector, auto-fetches from a remote source and
-*   ingests the result into storage (upsert), then pushes query result updates
-* - Optionally purges auto-fetched items for a selector once no observers remain
-* - Can subscribe to remote change notifications to re-fetch active selectors
-*
-* IMPORTANT: Purging only ever deletes items that were introduced via the
-* auto-fetch path and are no longer referenced by any active selector. Items
-* inserted through CRUD calls are never purged.
-*/
-var AutoFetchDataAdapter = class {
+var WorkerDataAdapterHost = class {
+	workerContext;
 	options;
 	id;
-	onError;
-	fetchQueryItems;
-	mergeItems;
-	purgeDelay;
+	log = () => {};
 	storageAdapters = /* @__PURE__ */ new Map();
 	storageAdapterReady = /* @__PURE__ */ new Map();
 	collectionIndices = /* @__PURE__ */ new Map();
 	queries = /* @__PURE__ */ new Map();
-	activeObservers = /* @__PURE__ */ new Map();
-	observerTimeouts = /* @__PURE__ */ new Map();
-	selectorIds = /* @__PURE__ */ new Map();
-	idRefCounts = /* @__PURE__ */ new Map();
-	autoloadIds = /* @__PURE__ */ new Map();
-	constructor(options) {
+	onError = (error) => {
+		console.error(error);
+	};
+	constructor(workerContext, options) {
+		this.workerContext = workerContext;
 		this.options = options;
-		this.id = options.id || "autofetch-data-adapter";
-		this.onError = options.onError ?? ((error) => {
-			console.error(error);
-		});
-		this.fetchQueryItems = options.fetchQueryItems;
-		this.mergeItems = options.mergeItems ?? defaultMergeItems;
-		this.purgeDelay = options.purgeDelay ?? 1e4;
-		if (options.registerRemoteChange) options.registerRemoteChange(async () => {
-			await this.forceRefetchAll();
-		});
-	}
-	createCollectionBackend(collection, indices) {
-		this.collectionIndices.set(collection.name, indices);
-		this.queries.set(collection.name, /* @__PURE__ */ new Map());
-		this.ensureStorageAdapter(collection.name);
-		this.activeObservers.set(collection.name, /* @__PURE__ */ new Map());
-		this.observerTimeouts.set(collection.name, /* @__PURE__ */ new Map());
-		this.selectorIds.set(collection.name, /* @__PURE__ */ new Map());
-		this.idRefCounts.set(collection.name, /* @__PURE__ */ new Map());
-		this.autoloadIds.set(collection.name, /* @__PURE__ */ new Set());
-		const ready = this.setupStorage(collection.name, indices);
-		this.storageAdapterReady.set(collection.name, ready);
-		const registerQuery = (selector, options) => {
-			const qid = require_queryId.default(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
-			});
-			const key = selectorId(selector);
-			const perColObservers = this.activeObservers.get(collection.name);
-			const current = perColObservers?.get(key)?.count ?? 0;
-			perColObservers?.set(key, {
-				selector,
-				count: current + 1
-			});
-			const t = this.observerTimeouts.get(collection.name)?.get(key);
-			if (t) clearTimeout(t);
-			if (current === 0) this.fetchAndIngest(collection.name, selector).catch(this.onError);
-			this.fulfillQuery(collection.name, selector, options).catch(this.onError);
-		};
-		const unregisterQuery = (selector, options) => {
-			const qid = require_queryId.default(selector, options);
-			this.queries.get(collection.name)?.delete(qid);
-			const key = selectorId(selector);
-			const perColObservers = this.activeObservers.get(collection.name);
-			const current = perColObservers?.get(key)?.count ?? 0;
-			const remaining = Math.max(0, current - 1);
-			if (remaining > 0) {
-				perColObservers?.set(key, {
-					selector,
-					count: remaining
-				});
-				return;
-			}
-			const doPurge = () => {
-				perColObservers?.delete(key);
-				this.purgeSelector(collection.name, selector).catch(this.onError);
-			};
-			if (this.purgeDelay === 0) doPurge();
-			else {
-				const timeouts = this.observerTimeouts.get(collection.name);
-				const t = timeouts?.get(key);
-				if (t) clearTimeout(t);
-				timeouts?.set(key, setTimeout(doPurge, this.purgeDelay));
-			}
-		};
-		const getQueryState = (selector, options) => {
-			return (this.queries.get(collection.name)?.get(require_queryId.default(selector, options)))?.state ?? "active";
-		};
-		const getQueryError = (selector, options) => {
-			return (this.queries.get(collection.name)?.get(require_queryId.default(selector, options)))?.error ?? null;
-		};
-		const getQueryResult = (selector, options) => {
-			return (this.queries.get(collection.name)?.get(require_queryId.default(selector, options)))?.items ?? [];
-		};
-		const onQueryStateChange = (selector, options, callback) => {
-			const qid = require_queryId.default(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()
-			});
-			registry.get(qid)?.listeners.add(callback);
-			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,
-			getQueryState,
-			getQueryError,
-			getQueryResult,
-			onQueryStateChange,
-			executeQuery: async (selector, options) => {
-				await ready;
-				registerQuery(selector, options);
-				await new Promise((resolve) => {
-					let stop = () => {};
-					stop = onQueryStateChange(selector, options, (state) => {
-						if (state === "active") return;
-						resolve();
-						stop();
-					});
-				});
-				const result = getQueryResult(selector, options);
-				unregisterQuery(selector, options);
-				return result;
-			},
-			dispose: async () => {
-				this.storageAdapters.delete(collection.name);
-				this.queries.delete(collection.name);
-				this.collectionIndices.delete(collection.name);
-				this.storageAdapterReady.delete(collection.name);
-				this.activeObservers.delete(collection.name);
-				this.observerTimeouts.delete(collection.name);
-				this.selectorIds.delete(collection.name);
-				this.idRefCounts.delete(collection.name);
-				this.autoloadIds.delete(collection.name);
-			},
-			isReady: async () => {
-				await ready;
+		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");
 	}
-	async forceRefetchAll() {
-		const tasks = [];
-		for (const [collectionName, observers] of this.activeObservers.entries()) for (const { selector, count } of observers.values()) if (count > 0) tasks.push(this.fetchAndIngest(collectionName, selector));
-		await Promise.all(tasks);
+	respond(id, data, error = null, type = "response") {
+		this.workerContext.postMessage({
+			id,
+			workerId: this.id,
+			type,
+			data,
+			error
+		});
 	}
-	async fetchAndIngest(collectionName, selector) {
-		this.publishForSelector(collectionName, selector, "active", null);
+	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`));
+			return;
+		}
+		this.log(method, ...args);
 		try {
-			const items = await this.fetchQueryItems(collectionName, selector);
-			if (!items || !Array.isArray(items)) throw new Error("AutoFetchDataAdapter: fetchQueryItems must resolve to { items: T[] }");
-			const ids = items.map((i) => i.id);
-			const selectorKey = selectorId(selector);
-			const selMap = this.selectorIds.get(collectionName);
-			const previous = selMap?.get(selectorKey) ?? /* @__PURE__ */ new Set();
-			ids.forEach((id) => previous.add(id));
-			selMap?.set(selectorKey, previous);
-			await this.upsertMerged(collectionName, items);
-			await this.checkQueryUpdates(collectionName, items);
+			await this.isReady(args[0]);
+			const result = await fn.apply(this, args);
+			this.respond(id, result);
 		} catch (error) {
-			this.publishForSelector(collectionName, selector, "error", error);
-			this.onError(error);
+			this.respond(id, null, error);
 		}
 	}
-	async purgeSelector(collectionName, selector) {
-		const selectorKey = selectorId(selector);
-		const selMap = this.selectorIds.get(collectionName);
-		const ids = selMap?.get(selectorKey);
-		selMap?.delete(selectorKey);
-		if (!ids || ids.size === 0) return;
-		const referenceMap = this.idRefCounts.get(collectionName);
-		const autoload = this.autoloadIds.get(collectionName);
-		const toRemove = [];
-		for (const id of ids) {
-			const current = referenceMap?.get(id) ?? 0;
-			const next = Math.max(0, current - 1);
-			if (next === 0) {
-				referenceMap?.delete(id);
-				if (autoload?.has(id)) toRemove.push(id);
-			} else referenceMap?.set(id, next);
-		}
-		if (toRemove.length === 0) return;
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const items = await storage.readIds(toRemove);
-		if (items.length > 0) {
-			await storage.remove(items);
-			await this.checkQueryUpdates(collectionName, items);
+	/**
+	* Reads one query's result from the storage adapter.
+	*
+	* Shares `executeStorageQuery` with `AsyncDataAdapter` and
+	* `AutoFetchDataAdapter`. It used to be the same eight lines in all three,
+	* which is how a storage-adapter capability ends up honoured by one of them
+	* and silently missing from the others — and how the primary-key fast path
+	* came to be maintained three times over.
+	* @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.
+	*/
+	async executeQuery(collectionName, selector, options) {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No storage adapter for collection ${collectionName}`);
+		return require_executeStorageQuery.default(storageAdapter, this.collectionIndices.get(collectionName) ?? [], selector, options);
+	}
+	ensureQuery(collectionName, selector, options) {
+		const id = require_queryId.default(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);
 		}
-		toRemove.forEach((id) => autoload?.delete(id));
+		return query;
+	}
+	setQueryItems(query, items) {
+		query.items = items;
+		query.itemIds = void 0;
+	}
+	queryItemIds(query) {
+		if (!query.itemIds) query.itemIds = new Set((query.items ?? []).map((item) => item.id));
+		return query.itemIds;
 	}
-	async setupStorage(collectionName, indices) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		await storage.setup();
-		await Promise.all(indices.map((field) => storage.createIndex(field)));
+	emitQueryUpdate(collectionName, selector, options, state, error, items, delta) {
+		const id = require_queryId.default(selector, options);
+		if (!this.queries.get(collectionName)) throw new Error(`Collection ${collectionName} not initialized!`);
+		this.respond(id, {
+			collectionName,
+			qid: id,
+			selector,
+			options,
+			state,
+			error,
+			items,
+			delta
+		}, null, "queryUpdate");
 	}
 	ensureStorageAdapter(name) {
 		if (this.storageAdapters.has(name)) return;
-		const adapter = this.options.storage && this.options.storage(name);
+		const adapter = this.options.storage(name);
 		if (!adapter) return;
 		this.storageAdapters.set(name, adapter);
 	}
-	publishForSelector(collectionName, selector, state, error) {
-		const registry = this.queries.get(collectionName);
-		if (!registry) return;
-		for (const query of registry.values()) {
-			if (!require_isEqual.default(query.selector, selector)) continue;
-			this.publishState(collectionName, require_queryId.default(query.selector, query.options), state, error);
-		}
-	}
-	publishState(collectionName, qid, state, error) {
-		const query = this.queries.get(collectionName)?.get(qid);
-		if (!query) return;
-		query.state = state;
-		query.error = error;
-		for (const callback of query.listeners) try {
-			callback(state);
-		} catch (error_) {
-			this.onError(error_);
-		}
-	}
-	publishResult(collectionName, qid, items) {
-		const query = this.queries.get(collectionName)?.get(qid);
-		if (!query) return;
-		query.items = items;
-		this.queries.get(collectionName)?.set(qid, query);
-	}
-	async fulfillQuery(collectionName, selector, options) {
-		const qid = require_queryId.default(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);
-		try {
-			const items = await this.executeQuery(collectionName, selector, options);
-			this.publishResult(collectionName, qid, items);
-			this.publishState(collectionName, qid, "complete", null);
-		} catch (error) {
-			this.publishState(collectionName, qid, "error", error);
-		}
+	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) || require_match.default(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 : require_incrementalQueryUpdate.default(previous, selector, options, changes);
+			if (incremental != null) {
+				const delta = require_queryDelta.diffQueryResults(previous, incremental);
+				if (require_queryDelta.isEmptyQueryDelta(delta)) return;
+				this.setQueryItems(query, incremental);
+				this.emitQueryUpdate(collectionName, selector, options, "complete", null, void 0, delta);
+				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);
+				return;
+			}
+			const delta = require_queryDelta.diffQueryResults(previous, queryItems);
+			this.setQueryItems(query, queryItems);
+			this.emitQueryUpdate(collectionName, selector, options, "complete", null, void 0, delta);
+		}));
 	}
-	async getIndexInfo(collectionName, selector) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		if (selector != null && Object.keys(selector).length === 1 && "id" in selector) {
-			const idResult = require_idIndexQuery.default(selector);
-			if (idResult.matched) return {
-				matched: true,
-				ids: idResult.ids,
-				optimizedSelector: {}
+	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 storage 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 = require_queryId.default(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 storage 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;
+		});
+		const newItems = result.filter((item) => !(item instanceof Error));
+		await storageAdapter.insert(newItems);
+		await this.checkQueryUpdates(collectionName, {
+			upserts: newItems,
+			deletes: []
+		});
+		return result;
+	};
+	updateOne = async (collectionName, parameters) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No storage adapter for collection ${collectionName}`);
+		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 {
+				items: [],
+				previousItems: []
 			};
-		}
-		if (selector == null) return {
-			matched: false,
-			ids: [],
-			optimizedSelector: {}
-		};
-		return require_getIndexInfo.default((this.collectionIndices.get(collectionName) ?? []).map((field) => require_storageIndexQuery.default(storage, field)), selector);
-	}
-	async queryItems(collectionName, selector) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const index = await this.getIndexInfo(collectionName, selector);
-		const matchItems = (item) => {
-			if (index.optimizedSelector == null) return true;
-			if (Object.keys(index.optimizedSelector).length <= 0) return true;
-			return require_match.default(item, index.optimizedSelector);
-		};
-		if (index.matched) {
-			const items = await storage.readIds(index.ids);
-			if (require_isEqual.default(index.optimizedSelector, {})) return items;
-			return items.filter(matchItems);
-		} else {
-			const allItems = await storage.readAll();
-			if (require_isEqual.default(selector, {})) return allItems;
-			return allItems.filter(matchItems);
-		}
-	}
-	async executeQuery(collectionName, selector, options) {
-		const items = await this.queryItems(collectionName, selector || {});
-		const { sort, skip, limit, fields } = options || {};
-		const sorted = sort ? require_sortItems.default(items, sort) : items;
-		const skipped = skip ? sorted.slice(skip) : sorted;
-		const limited = limit ? skipped.slice(0, limit) : skipped;
-		const idExcluded = fields && fields.id === 0;
-		return limited.map((item) => {
-			if (!fields) return item;
+			const modifiedItem = require_modify.default(require_deepClone.default(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 {
-				...idExcluded ? {} : { id: item.id },
-				...require_project.default(item, fields)
+				items: [modifiedItem],
+				previousItems: [item]
 			};
-		});
-	}
-	async checkQueryUpdates(collectionName, changedItems) {
-		const registry = this.queries.get(collectionName);
-		if (!registry) throw new Error(`Collection ${collectionName} not initialized!`);
-		if (registry.size === 0) return;
-		const affected = [...registry.values()].filter(({ selector }) => changedItems.some((item) => require_match.default(item, selector)));
-		if (affected.length === 0) return;
-		for (const { selector, options } of affected) {
-			const qid = require_queryId.default(selector, options);
-			this.publishState(collectionName, qid, "active", null);
+		}));
+		const written = result.filter((entry) => !(entry instanceof Error));
+		const modifiedItems = require_compact.default(written.flatMap((entry) => entry.items));
+		if (modifiedItems.length > 0) {
+			await storageAdapter.replace(modifiedItems);
+			await this.checkQueryUpdates(collectionName, toChangeset(require_compact.default(written.flatMap((entry) => entry.previousItems)), modifiedItems));
 		}
-		await Promise.all(affected.map(async ({ selector, options }) => {
-			const qid = require_queryId.default(selector, options);
+		return result;
+	};
+	updateMany = async (collectionName, parameters) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No storage adapter for collection ${collectionName}`);
+		const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
+			const items = await this.executeQuery(collectionName, selector);
+			if (items.length === 0) return {
+				items: [],
+				previousItems: []
+			};
+			const { $setOnInsert, ...restModifier } = modifier;
 			try {
-				const items = await this.executeQuery(collectionName, selector, options);
-				this.publishResult(collectionName, qid, items);
-				this.publishState(collectionName, qid, "complete", null);
+				return {
+					items: await Promise.all(items.map(async (item) => {
+						const modifiedItem = require_modify.default(require_deepClone.default(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`);
+						}
+						return modifiedItem;
+					})),
+					previousItems: items
+				};
 			} catch (error) {
-				this.publishState(collectionName, qid, "error", error);
+				return error;
 			}
 		}));
-	}
-	async insert(collectionName, newItem) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		if ((await this.executeQuery(collectionName, { id: newItem.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${String(newItem.id)} already exists`);
-		await storage.insert([newItem]);
-		await this.checkQueryUpdates(collectionName, [newItem]);
-		return newItem;
-	}
-	async updateOne(collectionName, selector, modifier) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const [item] = await this.executeQuery(collectionName, selector, { limit: 1 });
-		const { $setOnInsert, ...rest } = modifier;
-		if (item == null) return [];
-		const modified = require_modify.default(require_deepClone.default(item), rest);
-		if (item.id !== modified.id) {
-			if ((await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		const written = result.filter((entry) => !(entry instanceof Error));
+		const modifiedItems = require_compact.default(written.flatMap((entry) => entry.items));
+		if (modifiedItems.length > 0) {
+			await storageAdapter.replace(modifiedItems);
+			await this.checkQueryUpdates(collectionName, toChangeset(require_compact.default(written.flatMap((entry) => entry.previousItems)), modifiedItems));
 		}
-		await storage.replace([modified]);
-		await this.checkQueryUpdates(collectionName, [item, modified]);
-		return [modified];
-	}
-	async updateMany(collectionName, selector, modifier) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence 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 = require_modify.default(require_deepClone.default(item), rest);
-			if (item.id !== modified.id) {
-				if ((await this.executeQuery(collectionName, { id: modified.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		return result;
+	};
+	replaceOne = async (collectionName, parameters) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No storage adapter for collection ${collectionName}`);
+		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 {
+				items: [],
+				previousItems: []
+			};
+			const modifiedItem = {
+				...replacement,
+				id: replacement.id ?? item.id
+			};
+			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 modified;
+			return {
+				items: [modifiedItem],
+				previousItems: [item]
+			};
 		}));
-		await storage.replace(changed);
-		await this.checkQueryUpdates(collectionName, [...items, ...changed]);
-		return changed;
-	}
-	async replaceOne(collectionName, selector, replacement) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence 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 this.executeQuery(collectionName, { id: modified.id }, { limit: 1 })).length > 0) throw new Error(`Item with id ${String(modified.id)} already exists`);
+		const written = result.filter((entry) => !(entry instanceof Error));
+		const modifiedItems = require_compact.default(written.flatMap((entry) => entry.items));
+		if (modifiedItems.length > 0) {
+			await storageAdapter.replace(modifiedItems);
+			await this.checkQueryUpdates(collectionName, toChangeset(require_compact.default(written.flatMap((entry) => entry.previousItems)), modifiedItems));
 		}
-		await storage.replace([modified]);
-		await this.checkQueryUpdates(collectionName, [item, modified]);
-		return [modified];
-	}
-	async removeOne(collectionName, selector) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence 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, [item]);
-		return [item];
-	}
-	async removeMany(collectionName, selector) {
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const items = await this.executeQuery(collectionName, selector);
-		if (items.length === 0) return [];
-		await storage.remove(items);
-		await this.checkQueryUpdates(collectionName, items);
-		return items;
-	}
-	async upsertMerged(collectionName, incoming) {
-		if (incoming.length === 0) return;
-		const storage = this.storageAdapters.get(collectionName);
-		if (!storage) throw new Error(`No persistence adapter for collection ${collectionName}`);
-		const ids = incoming.map((i) => i.id);
-		const existing = await storage.readIds(ids);
-		const existingById = new Map(existing.map((it) => [it.id, it]));
-		const toInsert = [];
-		const toReplace = [];
-		const referenceMap = this.idRefCounts.get(collectionName);
-		const autoload = this.autoloadIds.get(collectionName);
-		for (const item of incoming) {
-			const previous = existingById.get(item.id);
-			if (previous) toReplace.push(this.mergeItems(previous, item));
-			else toInsert.push(item);
-			autoload?.add(item.id);
-			referenceMap?.set(item.id, (referenceMap?.get(item.id) ?? 0) + 1);
+		return result;
+	};
+	removeOne = async (collectionName, selectors) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No storage 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)
+			});
 		}
-		if (toInsert.length > 0) await storage.insert(toInsert);
-		if (toReplace.length > 0) await storage.replace(toReplace);
-	}
+		return result;
+	};
+	removeMany = async (collectionName, selectors) => {
+		const storageAdapter = this.storageAdapters.get(collectionName);
+		if (!storageAdapter) throw new Error(`No storage 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)
+			});
+		}
+		return result;
+	};
+	isReady = async (collectionName) => {
+		return this.storageAdapterReady.get(collectionName);
+	};
 };
-/**
-* Usage (example):
-*
-* const adapter = new AutoFetchDataAdapter({
-*   storage: (name) => new IndexedDBStorage(name),
-*   fetchQueryItems: async (collectionName, selector) => {
-*     const res = await fetch(`/api/${collectionName}?q=${encodeURIComponent(JSON.stringify(selector||{}))}`)
-*     const items = await res.json()
-*     return { items }
-*   },
-*   registerRemoteChange: (onChange) => subscribeToWS(onChange),
-*   mergeItems: (a, b) => ({ ...a, ...b }),
-*   purgeDelay: 10_000,
-* })
-*
-* const backend = adapter.createCollectionBackend(myCollection, ['status', 'projectId'])
-*/
 //#endregion
-exports.default = AutoFetchDataAdapter;
+exports.default = WorkerDataAdapterHost;