@signaldb/core 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/index25.cjs.js

@@ -1,558 +1,126 @@
-const require_Cursor = require("./index5.cjs.js");
-const require_EventEmitter = require("./index6.cjs.js");
-const require_createSignal = require("./index7.cjs.js");
-const require_randomId = require("./index8.cjs.js");
-require("./index14.cjs.js");
-const require_deepClone = require("./index17.cjs.js");
-const require_modify = require("./index19.cjs.js");
-const require_queryId = require("./index22.cjs.js");
-const require_DefaultDataAdapter = require("./index24.cjs.js");
-//#region src/Collection/index.ts
+const require_match = require("./index19.cjs.js");
+const require_projectItems = require("./index23.cjs.js");
+const require_sortItems = require("./index24.cjs.js");
+//#region src/utils/incrementalQueryUpdate.ts
 /**
-* Represents a collection of data items with support for in-memory operations,
-* persistence, reactivity, and event-based notifications. The collection provides
-* CRUD operations, observer patterns, and batch operations.
-* @template T - The type of the items stored in the collection.
-* @template I - The type of the unique identifier for the items.
-* @template U - The transformed item type after applying transformations (default is T).
+* Recomputes a query's result from its previous result and the change that was just written,
+* without going back to the store.
+*
+* A store re-executing the query instead reads every item it holds (or every item an index points
+* at) and filters, sorts and projects the lot — for a write that touched one row. This does the
+* same job in the size of the write, which is what a query's result costs to keep up to date when
+* the change that affects it is already in hand.
+*
+* Returns `null` when the previous result is not enough to answer, and the caller has to re-execute
+* the query after all:
+* - `limit` or `skip`: the result is a window onto a larger set, and an item leaving the window has
+*   to be replaced by one the previous result never contained.
+* - `fields` together with `sort`: the previous items are projected, so the field the sort is keyed
+*   on may no longer be there to sort by.
+* - a `null` selector, which matches nothing and is not worth a special case.
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns The new result, or `null` when the query has to be re-executed.
 */
-var Collection = class Collection extends require_EventEmitter.default {
-	static collections = [];
-	static debugMode = false;
-	static batchOperationInProgress = false;
-	static fieldTracking = false;
-	static onCreationCallbacks = [];
-	static onDisposeCallbacks = [];
-	static getCollections() {
-		return Collection.collections;
-	}
-	static onCreation(callback) {
-		Collection.onCreationCallbacks.push(callback);
-	}
-	static onDispose(callback) {
-		Collection.onDisposeCallbacks.push(callback);
-	}
-	/**
-	* Enables debug mode for all collections.
-	*/
-	static enableDebugMode = () => {
-		Collection.debugMode = true;
-		Collection.collections.forEach((collection) => {
-			collection.setDebugMode(true);
-		});
-	};
-	/**
-	* Enables field tracking for all collections.
-	* @param enable - A boolean indicating whether to enable field tracking.
-	*/
-	static setFieldTracking = (enable) => {
-		Collection.fieldTracking = enable;
-		Collection.collections.forEach((collection) => {
-			collection.setFieldTracking(enable);
-		});
-	};
-	static batch(callback) {
-		Collection.batchOperationInProgress = true;
-		const execute = () => Collection.collections.reduce((memo, collection) => () => {
-			return collection.batch(memo);
-		}, callback)();
-		const afterBatch = () => {
-			Collection.batchOperationInProgress = false;
-		};
-		let maybePromise;
-		try {
-			maybePromise = execute();
-		} catch (error) {
-			afterBatch();
-			throw error;
-		}
-		if (maybePromise && typeof maybePromise.then === "function") return maybePromise.then(() => afterBatch(), (error) => {
-			afterBatch();
-			throw error;
-		});
-		else afterBatch();
-	}
-	name;
-	backend;
-	options;
-	isPullingSignal;
-	isPushingSignal;
-	readySignal;
-	debugMode;
-	batchOperationInProgress = false;
-	isDisposed = false;
-	postBatchCallbacks = /* @__PURE__ */ new Set();
-	fieldTracking = false;
-	queryListenersMap = /* @__PURE__ */ new Map();
-	settledQueriesSet = /* @__PURE__ */ new Set();
-	constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
-		super();
-		const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${require_randomId.default()}`;
-		const options = typeof nameOrOptions === "string" ? maybeOptions || {} : nameOrOptions || {};
-		const persistence = options.persistence;
-		const dataAdapter = maybeDataAdapter || new require_DefaultDataAdapter.default({ ...persistence ? { storage: () => persistence } : {} });
-		Collection.collections.push(this);
-		this.name = name;
-		this.options = { ...options };
-		this.fieldTracking = this.options.fieldTracking ?? Collection.fieldTracking;
-		this.debugMode = this.options.enableDebugMode ?? Collection.debugMode;
-		this.isPullingSignal = require_createSignal.default(this.options.reactivity, false);
-		this.isPushingSignal = require_createSignal.default(this.options.reactivity, false);
-		this.readySignal = require_createSignal.default(this.options.reactivity, false);
-		this.backend = dataAdapter.createCollectionBackend(this, this.options.indices ?? []);
-		this.backend.isReady().then(() => {
-			this.readySignal.set(true);
-		}).catch(() => {});
-		Collection.onCreationCallbacks.forEach((callback) => callback(this));
-	}
-	isBatchOperationInProgress() {
-		return Collection.batchOperationInProgress || this.batchOperationInProgress;
-	}
-	/**
-	* Checks whether the collection is currently performing a pull operation
-	* ⚡️ this function is reactive!
-	* (loading data from the persistence adapter).
-	* @returns A boolean indicating if the collection is in the process of pulling data.
-	*/
-	isPulling() {
-		return this.isPullingSignal.get() ?? false;
-	}
-	/**
-	* Checks whether the collection is currently performing a push operation
-	* ⚡️ this function is reactive!
-	* (saving data to the persistence adapter).
-	* @returns A boolean indicating if the collection is in the process of pushing data.
-	*/
-	isPushing() {
-		return this.isPushingSignal.get() ?? false;
-	}
-	/**
-	* Checks whether the collection is currently performing either a pull or push operation,
-	* ⚡️ this function is reactive!
-	* indicating that it is loading or saving data.
-	* @returns A boolean indicating if the collection is in the process of loading or saving data.
-	*/
-	isLoading() {
-		const isPulling = this.isPulling();
-		const isPushing = this.isPushing();
-		return isPulling || isPushing;
-	}
-	/**
-	* Retrieves the current debug mode status of the collection.
-	* @returns A boolean indicating whether debug mode is enabled for the collection.
-	*/
-	getDebugMode() {
-		return this.debugMode;
-	}
-	/**
-	* Enables or disables debug mode for the collection.
-	* When debug mode is enabled, additional debugging information and events are emitted.
-	* @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) debug mode.
-	*/
-	setDebugMode(enable) {
-		this.debugMode = enable;
-	}
-	/**
-	* Enables or disables field tracking for the collection.
-	* @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) field tracking.
-	*/
-	setFieldTracking(enable) {
-		this.fieldTracking = enable;
-	}
-	/**
-	* Resolves when the persistence adapter finished initializing
-	* and the collection is ready to be used.
-	* @returns A promise that resolves when the collection is ready.
-	* @example
-	* ```ts
-	* const collection = new Collection({
-	*   persistence: // ...
-	* })
-	* await collection.isReady()
-	*
-	* collection.insert({ name: 'Item 1' })
-	*/
-	async ready() {
-		return this.backend.isReady();
-	}
-	/**
-	* Checks if the collection is ready.
-	* ⚡️ this function is reactive!
-	* @returns A boolean indicating whether the collection is ready.
-	*/
-	isReady() {
-		return this.readySignal.get() ?? false;
-	}
-	profile(fn, measureFunction) {
-		if (!this.debugMode) return fn();
-		const startTime = performance.now();
-		const handleProfileEnd = (result) => {
-			measureFunction(performance.now() - startTime);
-			return result;
-		};
-		const maybePromise = fn();
-		return maybePromise instanceof Promise ? maybePromise.then(handleProfileEnd) : handleProfileEnd(maybePromise);
-	}
-	executeInDebugMode(fn) {
-		if (!this.debugMode) return;
-		fn((/* @__PURE__ */ new Error()).stack || "");
-	}
-	transform(item) {
-		if (!this.options.transform) return item;
-		return this.options.transform(item);
-	}
-	transformAll(items, fields) {
-		if (!this.options.transformAll) return items;
-		return this.options.transformAll(require_deepClone.default(items), fields);
-	}
-	getItem(selector, options) {
-		const itemsOrPromise = this.getItems(selector, {
-			...options,
-			limit: 1
-		});
-		if (itemsOrPromise instanceof Promise) return itemsOrPromise.then((items) => {
-			return items[0] || void 0;
-		});
-		return itemsOrPromise[0];
-	}
-	getItems(selector, options) {
-		this.emit("getItems", selector);
-		return this.profile(() => {
-			if (!options?.async) return this.backend.getQueryResult(selector, options);
-			this.isPullingSignal.set(true);
-			return this.backend.executeQuery(selector, options).finally(() => {
-				this.isPullingSignal.set(false);
-			});
-		}, (measuredTime) => this.executeInDebugMode((callstack) => this.emit("_debug.getItems", callstack, selector, measuredTime)));
-	}
-	async withPushState(asyncFunction) {
-		this.isPushingSignal.set(true);
-		try {
-			return await asyncFunction();
-		} finally {
-			this.isPushingSignal.set(false);
-		}
-	}
-	queryListeners(query, listeners) {
-		const id = require_queryId.default(query.selector, query.options);
-		if (listeners != null) return this.queryListenersMap.set(id, listeners);
-		return this.queryListenersMap.get(id) ?? 0;
-	}
-	/**
-	* Disposes the collection, unregisters persistence adapters, clears memory, and
-	* cleans up all resources used by the collection.
-	* @returns A promise that resolves when the collection is disposed.
-	*/
-	async dispose() {
-		await this.backend.dispose();
-		this.isDisposed = true;
-		this.removeAllListeners();
-		Collection.collections = Collection.collections.filter((collection) => collection !== this);
-		Collection.onDisposeCallbacks.forEach((callback) => callback(this));
-	}
-	find(selector = {}, options) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (selector !== void 0 && (!selector || typeof selector !== "object")) throw new Error("Invalid selector");
-		const getTransformedItems = () => {
-			const itemsOrPromise = this.getItems(selector, options || {});
-			if (itemsOrPromise instanceof Promise) return itemsOrPromise.then((items) => {
-				return this.transformAll(items, options?.fields);
-			});
-			const items = itemsOrPromise;
-			return this.transformAll(items, options?.fields);
-		};
-		const cursor = new require_Cursor.default(getTransformedItems, {
-			reactive: this.options.reactivity,
-			fieldTracking: this.fieldTracking,
-			...options,
-			transform: this.transform.bind(this),
-			queryState: {
-				hasSettled: () => {
-					if (this.settledQueriesSet.has(require_queryId.default(selector, options))) return true;
-					const state = this.backend.getQueryState(selector, options || {});
-					return state === "complete" || state === "error";
-				},
-				onSettled: (callback) => this.backend.onQueryStateChange(selector, options || {}, (state) => {
-					if (state !== "complete" && state !== "error") return;
-					this.settledQueriesSet.add(require_queryId.default(selector, options));
-					callback();
-				})
-			},
-			bindEvents: (requery) => {
-				const handleRequery = () => {
-					if (this.batchOperationInProgress) {
-						this.postBatchCallbacks.add(requery);
-						return;
-					}
-					requery();
-				};
-				const listeners = this.queryListeners({
-					selector,
-					options
-				});
-				const didRegister = listeners === 0;
-				if (didRegister) this.backend.registerQuery(selector, options || {});
-				this.queryListeners({
-					selector,
-					options
-				}, listeners + 1);
-				const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
-					if (state === "error") {
-						const queryError = this.backend.getQueryError(selector, options || {}) || /* @__PURE__ */ new Error(`Query on "${this.name}" failed`);
-						this.emit("query.error", queryError, selector, options);
-						return;
-					}
-					if (state !== "complete") return;
-					handleRequery();
-				});
-				this.emit("observer.created", selector, options);
-				return () => {
-					queueMicrotask(() => {
-						const newListeners = Math.max(0, this.queryListeners({
-							selector,
-							options
-						}) - 1);
-						if (newListeners === 0 && didRegister) {
-							this.backend.unregisterQuery(selector, options || {});
-							this.settledQueriesSet.delete(require_queryId.default(selector, options));
-						}
-						this.queryListeners({
-							selector,
-							options
-						}, newListeners);
-						queryStateChangeCleanup();
-						this.emit("observer.disposed", selector, options);
-					});
-				};
-			}
-		});
-		this.emit("find", selector, options, cursor);
-		this.executeInDebugMode((callstack) => this.emit("_debug.find", callstack, selector, options, cursor));
-		return cursor;
-	}
-	findOne(selector, options) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		const cursor = this.find(selector, {
-			limit: 1,
-			...options
-		});
-		const handleItems = (items) => {
-			const returnValue = items[0] || void 0;
-			this.emit("findOne", selector, options, returnValue);
-			this.executeInDebugMode((callstack) => this.emit("_debug.findOne", callstack, selector, options, returnValue));
-			return returnValue;
-		};
-		const maybePromise = cursor.fetch();
-		return maybePromise instanceof Promise ? maybePromise.then(handleItems) : handleItems(maybePromise);
-	}
-	batch(callback) {
-		if (this.batchOperationInProgress) return callback();
-		this.batchOperationInProgress = true;
-		const afterBatch = () => {
-			this.batchOperationInProgress = false;
-			this.postBatchCallbacks.forEach((callback_) => callback_());
-			this.postBatchCallbacks.clear();
-		};
-		let maybePromise;
-		try {
-			maybePromise = callback();
-		} catch (error) {
-			afterBatch();
-			throw error;
-		}
-		if (maybePromise && typeof maybePromise.then === "function") return maybePromise.then(() => afterBatch(), (error) => {
-			afterBatch();
-			throw error;
-		});
-		else afterBatch();
-	}
-	onPostBatch(callback) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (this.batchOperationInProgress) {
-			this.postBatchCallbacks.add(callback);
-			return;
-		}
-		return callback();
-	}
-	/**
-	* Inserts a single item into the collection. Generates a unique ID if not provided.
-	* @param item - The item to insert.
-	* @returns The ID of the inserted item.
-	* @throws {Error} If the collection is disposed or the item has an invalid ID.
-	*/
-	async insert(item) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (!item) throw new Error("Invalid item");
-		const itemWithId = {
-			id: (this.options.primaryKeyGenerator ?? require_randomId.default)(item),
-			...item
-		};
-		this.emit("validate", itemWithId);
-		const newItem = await this.withPushState(() => this.backend.insert(itemWithId));
-		this.emit("added", newItem);
-		this.emit("insert", newItem);
-		this.executeInDebugMode((callstack) => this.emit("_debug.insert", callstack, newItem));
-		return newItem.id;
-	}
-	/**
-	* Inserts multiple items into the collection. Generates unique IDs for items if not provided.
-	* @param items - The items to insert.
-	* @returns An array of IDs of the inserted items.
-	* @throws {Error} If the collection is disposed or the items are invalid.
-	*/
-	async insertMany(items) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (!items) throw new Error("Invalid items");
-		if (items.length === 0) return [];
-		const ids = [];
-		await this.batch(async () => {
-			await Promise.all(items.map(async (item) => {
-				ids.push(await this.insert(item));
-			}));
-		});
-		return ids;
-	}
-	/**
-	* Updates a single item in the collection that matches the given selector.
-	* @param selector - The criteria to select the item to update.
-	* @param modifier - The modifications to apply to the item.
-	* @param [options] - Optional settings for the update operation.
-	* @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
-	* @returns The number of items updated (0 or 1).
-	* @throws {Error} If the collection is disposed or invalid arguments are provided.
-	*/
-	async updateOne(selector, modifier, options) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (!selector) throw new Error("Invalid selector");
-		if (!modifier) throw new Error("Invalid modifier");
-		const { $setOnInsert, ...restModifier } = modifier;
-		const item = await this.getItem(selector, { async: true });
-		if (item == null) {
-			if (options?.upsert) {
-				const newItem = require_modify.default({}, {
-					...restModifier,
-					$set: {
-						...$setOnInsert,
-						...restModifier.$set
-					}
-				});
-				await this.insert(newItem);
-				return 1;
-			}
-			return 0;
-		}
-		const modifiedItem = require_modify.default(require_deepClone.default(item), restModifier);
-		this.emit("validate", modifiedItem);
-		const changes = await this.withPushState(() => this.backend.updateOne(selector, modifier));
-		this.emit("changed", modifiedItem, restModifier);
-		this.emit("updateOne", selector, modifier);
-		this.executeInDebugMode((callstack) => this.emit("_debug.updateOne", callstack, selector, modifier));
-		return changes.length;
-	}
-	/**
-	* Updates multiple items in the collection that match the given selector.
-	* @param selector - The criteria to select the items to update.
-	* @param modifier - The modifications to apply to the items.
-	* @param [options] - Optional settings for the update operation.
-	* @param [options.upsert] - If `true`, creates new items if no items match the selector.
-	* @returns The number of items updated.
-	* @throws {Error} If the collection is disposed or invalid arguments are provided.
-	*/
-	async updateMany(selector, modifier, options) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (!selector) throw new Error("Invalid selector");
-		if (!modifier) throw new Error("Invalid modifier");
-		const { $setOnInsert, ...restModifier } = modifier;
-		const items = await this.getItems(selector, { async: true });
-		if (items.length === 0) {
-			if (options?.upsert) {
-				const newItem = require_modify.default({}, {
-					...restModifier,
-					$set: {
-						...$setOnInsert,
-						...restModifier.$set
-					}
-				});
-				await this.insert(newItem);
-				return 1;
-			}
-			return 0;
-		}
-		items.forEach((item) => {
-			const modifiedItem = require_modify.default(require_deepClone.default(item), restModifier);
-			this.emit("validate", modifiedItem);
-		});
-		const changes = await this.withPushState(() => this.backend.updateMany(selector, modifier));
-		changes.forEach((item) => {
-			this.emit("changed", item, restModifier);
-		});
-		this.emit("updateMany", selector, modifier);
-		this.executeInDebugMode((callstack) => this.emit("_debug.updateMany", callstack, selector, modifier));
-		return changes.length;
-	}
-	/**
-	* Replaces a single item in the collection that matches the given selector.
-	* @param selector - The criteria to select the item to replace.
-	* @param replacement - The item to replace the selected item with.
-	* @param [options] - Optional settings for the replace operation.
-	* @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
-	* @returns The number of items replaced (0 or 1).
-	* @throws {Error} If the collection is disposed or invalid arguments are provided.
-	*/
-	async replaceOne(selector, replacement, options) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (!selector) throw new Error("Invalid selector");
-		const item = await this.getItem(selector, { async: true });
-		if (item == null) {
-			if (options?.upsert) {
-				await this.insert(replacement);
-				return 1;
-			}
-			return 0;
+function incrementalQueryUpdate(previous, selector, options, changes) {
+	if (selector == null) return null;
+	const { sort, skip, limit, fields } = options || {};
+	if (skip != null) return null;
+	if (fields != null && sort != null) return null;
+	if (limit != null && !windowStaysClosed(previous, selector, options, changes)) return null;
+	return mergeChangesetIntoResult(previous, selector, options, changes);
+}
+/**
+* Whether two items are in the given order under the given sort, deciding ties against the caller.
+*
+* Uses the sort itself rather than a comparator of its own: a rule about which side of a window an
+* item falls on is only as good as its agreement with the ordering that drew the window. A tie
+* comes back as `false`, because a tie is exactly the case where an item could belong on either
+* side and the answer has to be taken from the store.
+* @template T - The type of the items.
+* @param item - The item whose position is in question.
+* @param edge - The item at the edge of the window.
+* @param sort - The query's sort.
+* @returns `true` when `item` sorts strictly before `edge`.
+*/
+function sortsBefore(item, edge, sort) {
+	return require_sortItems.default([edge, item], sort)[0] === item;
+}
+/**
+* Whether a change to a windowed query can be answered from the window alone.
+*
+* A window holds the first `limit` items in sort order, and nothing about what lies beyond it. An
+* item leaving the window therefore has to be replaced by one the window has never seen, and that
+* answer can only come from the store. An item arriving is a different matter: it takes its place
+* and pushes the last one out, and where that one goes is not the window's problem.
+*
+* The one case where none of this applies is a window that was never full, because then the query
+* already returns everything it matches and there is no "beyond".
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns `true` when the new window follows from the old one and the change.
+*/
+function windowStaysClosed(previous, selector, options, changes) {
+	const { sort, limit, fields } = options || {};
+	if (limit == null || previous.length < limit) return true;
+	if (sort == null || fields != null) return false;
+	const edge = previous.at(-1);
+	const runnerUp = previous.at(-2);
+	if (runnerUp != null && !sortsBefore(runnerUp, edge, sort)) return false;
+	const inWindow = new Set(previous.map((item) => item.id));
+	if (changes.deletes.some((id) => inWindow.has(id))) return false;
+	return changes.upserts.every((item) => {
+		if (item === edge) return true;
+		const before = sortsBefore(item, edge, sort);
+		if (!inWindow.has(item.id)) {
+			if (!require_match.default(item, selector)) return true;
+			return before || sortsBefore(edge, item, sort);
 		}
-		const modifiedItem = {
-			id: item.id,
-			...replacement
-		};
-		this.emit("validate", modifiedItem);
-		const changes = await this.withPushState(() => this.backend.replaceOne(selector, replacement));
-		this.emit("changed", modifiedItem, replacement);
-		this.emit("replaceOne", selector, replacement);
-		this.executeInDebugMode((callstack) => this.emit("_debug.replaceOne", callstack, selector, replacement));
-		return changes.length;
-	}
-	/**
-	* Removes a single item from the collection that matches the given selector.
-	* @param selector - The criteria to select the item to remove.
-	* @returns The number of items removed (0 or 1).
-	* @throws {Error} If the collection is disposed or invalid arguments are provided.
-	*/
-	async removeOne(selector) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (!selector) throw new Error("Invalid selector");
-		const removedItems = await this.withPushState(() => this.backend.removeOne(selector));
-		this.emit("removed", removedItems[0]);
-		this.emit("removeOne", selector);
-		this.executeInDebugMode((callstack) => this.emit("_debug.removeOne", callstack, selector));
-		return removedItems.length;
-	}
-	/**
-	* Removes multiple items from the collection that match the given selector.
-	* @param selector - The criteria to select the items to remove.
-	* @returns The number of items removed.
-	* @throws {Error} If the collection is disposed or invalid arguments are provided.
-	*/
-	async removeMany(selector) {
-		if (this.isDisposed) throw new Error("Collection is disposed");
-		if (!selector) throw new Error("Invalid selector");
-		const removedItems = await this.withPushState(() => this.backend.removeMany(selector));
-		removedItems.forEach((item) => {
-			this.emit("removed", item);
-		});
-		this.emit("removeMany", selector);
-		this.executeInDebugMode((callstack) => this.emit("_debug.removeMany", callstack, selector));
-		return removedItems.length;
-	}
-};
+		if (!require_match.default(item, selector)) return false;
+		if (before) return true;
+		return item.id === edge.id && !sortsBefore(edge, item, sort);
+	});
+}
+/**
+* Folds a change into a query's result, whatever the query's options.
+*
+* The unguarded version of `incrementalQueryUpdate`, for the places where the alternative is not a
+* more accurate answer but a wrong one — layering a write that has not been confirmed yet on top of
+* the last confirmed result, say. For a query returning everything it matches, this is exact. For a
+* window onto a larger set it is the closest the window itself can get: an item that no longer
+* belongs is dropped, one that does is placed, and the window is trimmed back to its length — but
+* an item pulled in from beyond the window is not something the window knows about.
+*
+* What it never does is re-examine the items already in the result. They matched when the store
+* produced them, they still match, and asking again is both wasteful and — for a projected result,
+* whose items no longer carry the fields the selector names — wrong.
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns The resulting items.
+*/
+function mergeChangesetIntoResult(previous, selector, options, changes) {
+	if (selector == null) return [];
+	const { sort, limit, fields } = options || {};
+	const byId = /* @__PURE__ */ new Map();
+	previous.forEach((item) => byId.set(item.id, item));
+	changes.deletes.forEach((id) => byId.delete(id));
+	changes.upserts.forEach((item) => {
+		if (require_match.default(item, selector)) byId.set(item.id, require_projectItems.default([item], fields)[0]);
+		else byId.delete(item.id);
+	});
+	const items = [...byId.values()];
+	const sorted = sort ? require_sortItems.default(items, sort) : items;
+	return limit == null ? sorted : sorted.slice(0, limit);
+}
 //#endregion
-exports.default = Collection;
+exports.default = incrementalQueryUpdate;
+exports.mergeChangesetIntoResult = mergeChangesetIntoResult;