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

package/dist/.vite/manifest.json

@@ -1,6 +1,6 @@
 {
   "src/AsyncDataAdapter.ts": {
-    "file": "index29.cjs.js",
+    "file": "index32.cjs.js",
     "name": "AsyncDataAdapter",
     "src": "src/AsyncDataAdapter.ts",
     "isDynamicEntry": true,
@@ -8,16 +8,18 @@
       "src/getIndexInfo.ts",
       "src/utils/deepClone.ts",
       "src/utils/getMatchingKeys.ts",
+      "src/utils/incrementalQueryUpdate.ts",
       "src/utils/isEqual.ts",
       "src/utils/match.ts",
       "src/utils/modify.ts",
-      "src/utils/project.ts",
+      "src/utils/projectItems.ts",
+      "src/utils/queryDelta.ts",
       "src/utils/queryId.ts",
       "src/utils/sortItems.ts"
     ]
   },
   "src/AutoFetchDataAdapter.ts": {
-    "file": "index35.cjs.js",
+    "file": "index37.cjs.js",
     "name": "AutoFetchDataAdapter",
     "src": "src/AutoFetchDataAdapter.ts",
     "isDynamicEntry": true,
@@ -34,7 +36,7 @@
     ]
   },
   "src/Collection/Cursor.ts": {
-    "file": "index5.cjs.js",
+    "file": "index6.cjs.js",
     "name": "Collection/Cursor",
     "src": "src/Collection/Cursor.ts",
     "isDynamicEntry": true,
@@ -43,17 +45,18 @@
     ]
   },
   "src/Collection/Observer.ts": {
-    "file": "index4.cjs.js",
+    "file": "index5.cjs.js",
     "name": "Collection/Observer",
     "src": "src/Collection/Observer.ts",
     "isDynamicEntry": true,
     "imports": [
       "src/utils/isEqual.ts",
+      "src/utils/queryDelta.ts",
       "src/utils/uniqueBy.ts"
     ]
   },
   "src/Collection/index.ts": {
-    "file": "index25.cjs.js",
+    "file": "index28.cjs.js",
     "name": "Collection/index",
     "src": "src/Collection/index.ts",
     "isDynamicEntry": true,
@@ -70,7 +73,7 @@
     ]
   },
   "src/DefaultDataAdapter.ts": {
-    "file": "index24.cjs.js",
+    "file": "index27.cjs.js",
     "name": "DefaultDataAdapter",
     "src": "src/DefaultDataAdapter.ts",
     "isDynamicEntry": true,
@@ -79,32 +82,35 @@
       "src/getIndexInfo.ts",
       "src/utils/EventEmitter.ts",
       "src/utils/deepClone.ts",
+      "src/utils/incrementalQueryUpdate.ts",
       "src/utils/isEqual.ts",
       "src/utils/match.ts",
       "src/utils/modify.ts",
-      "src/utils/project.ts",
+      "src/utils/projectItems.ts",
+      "src/utils/queryDelta.ts",
       "src/utils/queryId.ts",
       "src/utils/serializeValue.ts",
       "src/utils/sortItems.ts"
     ]
   },
   "src/WorkerDataAdapter.ts": {
-    "file": "index32.cjs.js",
+    "file": "index34.cjs.js",
     "name": "WorkerDataAdapter",
     "src": "src/WorkerDataAdapter.ts",
     "isDynamicEntry": true,
     "imports": [
-      "src/utils/applyQueryOptions.ts",
       "src/utils/batchOnNextTick.ts",
       "src/utils/deepClone.ts",
+      "src/utils/incrementalQueryUpdate.ts",
       "src/utils/match.ts",
       "src/utils/modify.ts",
+      "src/utils/queryDelta.ts",
       "src/utils/queryId.ts",
       "src/utils/randomId.ts"
     ]
   },
   "src/WorkerDataAdapterHost.ts": {
-    "file": "index34.cjs.js",
+    "file": "index36.cjs.js",
     "name": "WorkerDataAdapterHost",
     "src": "src/WorkerDataAdapterHost.ts",
     "isDynamicEntry": true,
@@ -113,16 +119,18 @@
       "src/utils/compact.ts",
       "src/utils/deepClone.ts",
       "src/utils/getMatchingKeys.ts",
+      "src/utils/incrementalQueryUpdate.ts",
       "src/utils/isEqual.ts",
       "src/utils/match.ts",
       "src/utils/modify.ts",
-      "src/utils/project.ts",
+      "src/utils/projectItems.ts",
+      "src/utils/queryDelta.ts",
       "src/utils/queryId.ts",
       "src/utils/sortItems.ts"
     ]
   },
   "src/createIndex.ts": {
-    "file": "index14.cjs.js",
+    "file": "index15.cjs.js",
     "name": "createIndex",
     "src": "src/createIndex.ts",
     "isDynamicEntry": true,
@@ -134,25 +142,25 @@
     ]
   },
   "src/createIndexProvider.ts": {
-    "file": "index9.cjs.js",
+    "file": "index10.cjs.js",
     "name": "createIndexProvider",
     "src": "src/createIndexProvider.ts",
     "isDynamicEntry": true
   },
   "src/createReactivityAdapter.ts": {
-    "file": "index27.cjs.js",
+    "file": "index30.cjs.js",
     "name": "createReactivityAdapter",
     "src": "src/createReactivityAdapter.ts",
     "isDynamicEntry": true
   },
   "src/createStorageAdapter.ts": {
-    "file": "index26.cjs.js",
+    "file": "index29.cjs.js",
     "name": "createStorageAdapter",
     "src": "src/createStorageAdapter.ts",
     "isDynamicEntry": true
   },
   "src/getIndexInfo.ts": {
-    "file": "index16.cjs.js",
+    "file": "index17.cjs.js",
     "name": "getIndexInfo",
     "src": "src/getIndexInfo.ts",
     "isDynamicEntry": true,
@@ -185,54 +193,43 @@
     ]
   },
   "src/utils/EventEmitter.ts": {
-    "file": "index6.cjs.js",
+    "file": "index7.cjs.js",
     "name": "utils/EventEmitter",
     "src": "src/utils/EventEmitter.ts",
     "isDynamicEntry": true
   },
-  "src/utils/applyQueryOptions.ts": {
-    "file": "index31.cjs.js",
-    "name": "utils/applyQueryOptions",
-    "src": "src/utils/applyQueryOptions.ts",
-    "isDynamicEntry": true,
-    "imports": [
-      "src/utils/match.ts",
-      "src/utils/project.ts",
-      "src/utils/sortItems.ts"
-    ]
-  },
   "src/utils/batchOnNextTick.ts": {
-    "file": "index30.cjs.js",
+    "file": "index33.cjs.js",
     "name": "utils/batchOnNextTick",
     "src": "src/utils/batchOnNextTick.ts",
     "isDynamicEntry": true
   },
   "src/utils/compact.ts": {
-    "file": "index33.cjs.js",
+    "file": "index35.cjs.js",
     "name": "utils/compact",
     "src": "src/utils/compact.ts",
     "isDynamicEntry": true
   },
   "src/utils/createSignal.ts": {
-    "file": "index7.cjs.js",
+    "file": "index8.cjs.js",
     "name": "utils/createSignal",
     "src": "src/utils/createSignal.ts",
     "isDynamicEntry": true
   },
   "src/utils/deepClone.ts": {
-    "file": "index17.cjs.js",
+    "file": "index18.cjs.js",
     "name": "utils/deepClone",
     "src": "src/utils/deepClone.ts",
     "isDynamicEntry": true
   },
   "src/utils/get.ts": {
-    "file": "index10.cjs.js",
+    "file": "index11.cjs.js",
     "name": "utils/get",
     "src": "src/utils/get.ts",
     "isDynamicEntry": true
   },
   "src/utils/getMatchingKeys.ts": {
-    "file": "index13.cjs.js",
+    "file": "index14.cjs.js",
     "name": "utils/getMatchingKeys",
     "src": "src/utils/getMatchingKeys.ts",
     "isDynamicEntry": true,
@@ -241,8 +238,19 @@
       "src/utils/serializeValue.ts"
     ]
   },
+  "src/utils/incrementalQueryUpdate.ts": {
+    "file": "index25.cjs.js",
+    "name": "utils/incrementalQueryUpdate",
+    "src": "src/utils/incrementalQueryUpdate.ts",
+    "isDynamicEntry": true,
+    "imports": [
+      "src/utils/match.ts",
+      "src/utils/projectItems.ts",
+      "src/utils/sortItems.ts"
+    ]
+  },
   "src/utils/intersection.ts": {
-    "file": "index15.cjs.js",
+    "file": "index16.cjs.js",
     "name": "utils/intersection",
     "src": "src/utils/intersection.ts",
     "isDynamicEntry": true
@@ -254,19 +262,19 @@
     "isDynamicEntry": true
   },
   "src/utils/isFieldExpression.ts": {
-    "file": "index11.cjs.js",
+    "file": "index12.cjs.js",
     "name": "utils/isFieldExpression",
     "src": "src/utils/isFieldExpression.ts",
     "isDynamicEntry": true
   },
   "src/utils/match.ts": {
-    "file": "index18.cjs.js",
+    "file": "index19.cjs.js",
     "name": "utils/match",
     "src": "src/utils/match.ts",
     "isDynamicEntry": true
   },
   "src/utils/modify.ts": {
-    "file": "index19.cjs.js",
+    "file": "index20.cjs.js",
     "name": "utils/modify",
     "src": "src/utils/modify.ts",
     "isDynamicEntry": true,
@@ -275,7 +283,7 @@
     ]
   },
   "src/utils/project.ts": {
-    "file": "index21.cjs.js",
+    "file": "index22.cjs.js",
     "name": "utils/project",
     "src": "src/utils/project.ts",
     "isDynamicEntry": true,
@@ -284,38 +292,56 @@
       "src/utils/set.ts"
     ]
   },
+  "src/utils/projectItems.ts": {
+    "file": "index23.cjs.js",
+    "name": "utils/projectItems",
+    "src": "src/utils/projectItems.ts",
+    "isDynamicEntry": true,
+    "imports": [
+      "src/utils/project.ts"
+    ]
+  },
+  "src/utils/queryDelta.ts": {
+    "file": "index4.cjs.js",
+    "name": "utils/queryDelta",
+    "src": "src/utils/queryDelta.ts",
+    "isDynamicEntry": true,
+    "imports": [
+      "src/utils/isEqual.ts"
+    ]
+  },
   "src/utils/queryId.ts": {
-    "file": "index22.cjs.js",
+    "file": "index26.cjs.js",
     "name": "utils/queryId",
     "src": "src/utils/queryId.ts",
     "isDynamicEntry": true
   },
   "src/utils/randomId.ts": {
-    "file": "index8.cjs.js",
+    "file": "index9.cjs.js",
     "name": "utils/randomId",
     "src": "src/utils/randomId.ts",
     "isDynamicEntry": true
   },
   "src/utils/reactiveOrAsync.ts": {
-    "file": "index28.cjs.js",
+    "file": "index31.cjs.js",
     "name": "utils/reactiveOrAsync",
     "src": "src/utils/reactiveOrAsync.ts",
     "isDynamicEntry": true
   },
   "src/utils/serializeValue.ts": {
-    "file": "index12.cjs.js",
+    "file": "index13.cjs.js",
     "name": "utils/serializeValue",
     "src": "src/utils/serializeValue.ts",
     "isDynamicEntry": true
   },
   "src/utils/set.ts": {
-    "file": "index20.cjs.js",
+    "file": "index21.cjs.js",
     "name": "utils/set",
     "src": "src/utils/set.ts",
     "isDynamicEntry": true
   },
   "src/utils/sortItems.ts": {
-    "file": "index23.cjs.js",
+    "file": "index24.cjs.js",
     "name": "utils/sortItems",
     "src": "src/utils/sortItems.ts",
     "isDynamicEntry": true,

package/dist/AsyncDataAdapter.d.ts

@@ -80,16 +80,25 @@ export default class AsyncDataAdapter implements DataAdapter {
      * @param qid - query id
      * @param state - new state
      * @param error - error if state is 'error', null otherwise
+     * @param delta - what changed about the result, when that is known
      */
     private publishState;
     private publishResult;
+    private queryItemIds;
     private getIndexInfo;
     private queryItems;
     private executeQuery;
     /**
-     * After mutations, recompute and push updates for affected active queries
+     * After mutations, bring every affected active query up to date.
+     *
+     * A query whose previous result is enough to answer the change is brought up to date from that
+     * result alone — no round trip to the storage, and no detour through `'active'`, because there is
+     * no window in which the query is stale. Only a query the change cannot be reasoned about
+     * locally — a window onto a larger set, or one that has never been answered — goes back to the
+     * store, and that one gets the same retry and reporting behaviour a freshly registered query
+     * gets: a refresh that fails silently leaves exactly the same dead cursor.
      * @param collectionName - name of the collection
-     * @param affectedItems - item states before and/or after the mutation
+     * @param changes - the items the write created, updated or removed
      */
     private checkQueryUpdates;
     private insert;

package/dist/Collection/Cursor.d.ts

@@ -1,4 +1,5 @@
 import { default as ReactivityAdapter } from '../types/ReactivityAdapter';
+import { QueryDelta } from '../utils/queryDelta';
 import { BaseItem, FindOptions, Transform } from './types';
 import { ObserveCallbacks } from './Observer';
 /**
@@ -25,7 +26,7 @@ export interface QueryStateAccessor {
 }
 export interface CursorOptions<T extends BaseItem, U = T, Async extends boolean = false> extends FindOptions<T, Async> {
     transform?: Transform<T, U>;
-    bindEvents?: (requery: () => void) => () => void;
+    bindEvents?: (requery: () => void, applyDelta: (delta: QueryDelta<T>) => void) => () => void;
     queryState?: QueryStateAccessor;
 }
 /**
@@ -152,4 +153,13 @@ export default class Cursor<T extends BaseItem, U = T, Async extends boolean = f
      * criteria have changed, and you want to ensure the cursor reflects the latest state.
      */
     requery(): void;
+    /**
+     * Brings the cursor up to date from a description of what changed, rather than by re-running the
+     * query and comparing the result with the previous one.
+     *
+     * Falls back to `requery` when the delta does not fit the result the cursor currently holds, so
+     * a caller never has to decide which of the two is safe.
+     * @param delta - The change to apply.
+     */
+    applyDelta(delta: QueryDelta<T>): void;
 }

package/dist/Collection/Observer.d.ts

@@ -1,3 +1,4 @@
+import { QueryDelta } from '../utils/queryDelta';
 type AddedCallback<T> = (item: T) => void;
 type AddedBeforeCallback<T> = (item: T, before: T) => void;
 type ChangedCallback<T> = (item: T) => void;
@@ -42,6 +43,36 @@ export default class Observer<T extends {
      * @param getItems - A function that returns a promise resolving to the new items or the items themselves.
      */
     runChecks(getItems: () => Promise<T[]> | T[]): void;
+    /**
+     * Brings the observer up to date from a description of what changed, instead of from the new
+     * result.
+     *
+     * `runChecks` has to rediscover the change by comparing the whole new result against the whole
+     * old one — a cost proportional to the result, paid on every write, to find out that one row
+     * moved. When the change is already known it can simply be reported, and the cost becomes
+     * proportional to the change.
+     *
+     * The delta must have been computed against exactly the result this observer holds. If it was
+     * not, this reports nothing, falls back to `runChecks`, and returns `false`.
+     *
+     * Note that the reported moves are minimal, where a comparison reports every item whose
+     * neighbour changed. Applying them yields the same order either way — there are simply fewer of
+     * them.
+     * @param delta - The change to report.
+     * @param getItems - Used to fall back to a comparison when the delta cannot be applied.
+     * @returns Whether the delta was applied.
+     */
+    applyDelta(delta: QueryDelta<T>, getItems: () => Promise<T[]> | T[]): boolean;
+    /**
+     * Reports a delta and adopts the result it produces.
+     *
+     * The single place the callbacks are fired from, whether the change arrived as a delta or was
+     * found by comparing two results — so the two can never disagree about what a consumer is told.
+     * @param delta - The change to report.
+     * @param nextItems - The result the delta produces.
+     */
+    private emitDelta;
+    private finishCheck;
     private checkItems;
     private stopped;
     /**

package/dist/Collection/index.d.ts

@@ -74,7 +74,22 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
     private static fieldTracking;
     private static onCreationCallbacks;
     private static onDisposeCallbacks;
+    private static largeQueryWarningThreshold;
+    private static reportedLargeQueries;
     static getCollections(): Collection<any, any, any, any>[];
+    /**
+     * Reports live queries whose result is larger than `rows`, once each, with
+     * the stack that registered them.
+     *
+     * A reactive query is re-evaluated whenever the data under it changes, and
+     * one registered from a long-lived place — a navigation bar, a provider
+     * near the root — keeps that cost for the lifetime of the application. There
+     * is otherwise nothing to see: the query works, and its price is only
+     * visible as an application that has grown slow. Finding one such query in a
+     * real app took a purpose-built profiler and the better part of a day.
+     * @param rows - Result size to report above, or `null` to switch the check off.
+     */
+    static reportLargeQueries(rows: number | null): void;
     static onCreation(callback: (collection: Collection<any>) => void): void;
     static onDispose(callback: (collection: Collection<any>) => void): void;
     /**
@@ -92,11 +107,27 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
      * This improves performance by avoiding repetitive index recalculations and
      * provides atomicity for the batch of operations.
      * Supports both synchronous and asynchronous callbacks.
+     *
+     * **Without a `collections` argument this affects every collection in the
+     * process, not only the ones being written to.** Each of them defers every
+     * live query's requery until the batch ends. That is what makes a batch
+     * cheap for a handful of writes belonging to one event, and what makes it
+     * dangerous around a loop whose length is data-dependent: while it is open
+     * nothing anywhere updates, and everything deferred is flushed at once when
+     * it closes. One application wrapped a sync of roughly 1,100 records this
+     * way and its screens stopped resolving their data for the whole drain.
+     *
+     * Pass the collections being written to whenever that scope is known — it is
+     * both cheaper and safer. `Collection.batch([logs, versions], () => …)`
+     * defers those two and leaves everything else live.
+     * @param collections - The collections to batch. Omit to batch all of them.
      * @param callback - The batch operation to execute.
      * @returns A promise if the callback returns a promise, otherwise `void`.
      */
     static batch<ReturnType>(callback: () => Promise<ReturnType>): Promise<void>;
     static batch<ReturnType>(callback: () => ReturnType): void;
+    static batch<ReturnType>(collections: Collection<any, any, any, any>[], callback: () => Promise<ReturnType>): Promise<void>;
+    static batch<ReturnType>(collections: Collection<any, any, any, any>[], callback: () => ReturnType): void;
     readonly name: string;
     private backend;
     private options;
@@ -131,6 +162,15 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
      */
     constructor(options?: CollectionOptions<T, I, E, U>);
     constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, E, U>);
+    /**
+     * Reports a live query the first time its result is found to be larger than
+     * the configured threshold. Once per query, because it re-runs on every
+     * write and a warning per write would be its own performance problem.
+     * @param selector - The query's selector.
+     * @param options - The query's options.
+     * @param registrationStack - Where the query was registered, if captured.
+     */
+    private reportIfLargeQuery;
     isBatchOperationInProgress(): boolean;
     /**
      * Checks whether the collection is currently performing a pull operation

package/dist/DataAdapter.d.ts

@@ -1,6 +1,7 @@
 import { BaseItem, FieldSpecifier, SortSpecifier, default as Collection } from './Collection';
 import { default as Modifier } from './types/Modifier';
 import { default as Selector } from './types/Selector';
+import { QueryDelta } from './utils/queryDelta';
 export interface QueryOptions<T extends BaseItem> {
     /** Sort order (default: natural order) */
     sort?: SortSpecifier<T> | undefined;
@@ -11,7 +12,19 @@ export interface QueryOptions<T extends BaseItem> {
     /** Dictionary of fields to return or exclude. */
     fields?: FieldSpecifier<T> | undefined;
 }
-export type StateChangeCallback = (state: 'active' | 'complete' | 'error') => void;
+/**
+ * Notified when a query's state changes.
+ *
+ * A `'complete'` notification may carry a delta describing how the result changed since the last
+ * one. An adapter that can produce one saves its listeners from rediscovering the change by
+ * comparing the whole result against the whole previous result; one that cannot simply omits it,
+ * and its listeners fall back to exactly that comparison.
+ *
+ * A delta is only ever passed when it is relative to what `getQueryResult` returned the last time
+ * it was asked. An adapter that layers anything on top of its stored result — an optimistic write
+ * still in flight, for instance — must omit the delta for as long as it does.
+ */
+export type StateChangeCallback<T extends BaseItem = BaseItem> = (state: 'active' | 'complete' | 'error', delta?: QueryDelta<T>) => void;
 export interface CollectionBackend<T extends BaseItem<I>, I> {
     insert(item: T): Promise<T>;
     updateOne(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
@@ -31,7 +44,7 @@ export interface CollectionBackend<T extends BaseItem<I>, I> {
     getQueryError<O extends QueryOptions<T>>(selector: Selector<T>, options: O): Error | null;
     getQueryResult<O extends QueryOptions<T>>(selector: Selector<T>, options: O): T[];
     executeQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): Promise<T[]>;
-    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T>, options: O, callback: StateChangeCallback): () => void;
+    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T>, options: O, callback: StateChangeCallback<T>): () => void;
     dispose(): Promise<void>;
     isReady(): Promise<void>;
 }

package/dist/WorkerDataAdapter.d.ts

@@ -20,12 +20,33 @@ export default class WorkerDataAdapter implements DataAdapter {
     private collectionReady;
     private batchExecutionHelpers;
     private queries;
+    private pendingRequests;
     private pendingWrites;
     private pendingWriteSeq;
+    private pendingWriteVersions;
+    private bumpPendingWriteVersion;
     constructor(worker: WorkerDataAdapterEndpoint, options: WorkerDataAdapterOptions);
+    private resolveWorkerReady;
+    private handleWorkerMessage;
+    private handleQueryUpdate;
     private exec;
+    /**
+     * 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.
+     */
+    private execInBackground;
+    private queryItemsById;
+    private flattenPendingWrites;
+    private static providesFullItems;
     private observableItems;
-    private mergePendingWrites;
+    private observableItemsByIds;
+    private servedResult;
+    private computeServedResult;
     /**
      * Registers a write's effect locally and notifies every active query it
      * touches, then returns a function that drops it again once the write
@@ -36,7 +57,9 @@ export default class WorkerDataAdapter implements DataAdapter {
      * @returns A function that drops the pending write and re-notifies.
      */
     private applyPendingWrite;
-    private notifyAffectedQueries;
+    private affectedQueries;
+    private servedResults;
+    private notifyWithDeltas;
     private matchObservableItems;
     private resolveUpdate;
     private resolveRemoval;

package/dist/WorkerDataAdapterHost.d.ts

@@ -44,6 +44,8 @@ export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
     private queryItems;
     private executeQuery;
     private ensureQuery;
+    private setQueryItems;
+    private queryItemIds;
     private emitQueryUpdate;
     private ensureStorageAdapter;
     private checkQueryUpdates;

package/dist/index.cjs.js

@@ -1,20 +1,20 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_isEqual = require("./index2.cjs.js");
-const require_Cursor = require("./index5.cjs.js");
-const require_EventEmitter = require("./index6.cjs.js");
-const require_randomId = require("./index8.cjs.js");
-const require_get = require("./index10.cjs.js");
-const require_serializeValue = require("./index12.cjs.js");
-const require_modify = require("./index19.cjs.js");
-const require_DefaultDataAdapter = require("./index24.cjs.js");
-const require_index = require("./index25.cjs.js");
-const require_createStorageAdapter = require("./index26.cjs.js");
-const require_createReactivityAdapter = require("./index27.cjs.js");
-const require_reactiveOrAsync = require("./index28.cjs.js");
-const require_AsyncDataAdapter = require("./index29.cjs.js");
-const require_WorkerDataAdapter = require("./index32.cjs.js");
-const require_WorkerDataAdapterHost = require("./index34.cjs.js");
-const require_AutoFetchDataAdapter = require("./index35.cjs.js");
+const require_Cursor = require("./index6.cjs.js");
+const require_EventEmitter = require("./index7.cjs.js");
+const require_randomId = require("./index9.cjs.js");
+const require_get = require("./index11.cjs.js");
+const require_serializeValue = require("./index13.cjs.js");
+const require_modify = require("./index20.cjs.js");
+const require_DefaultDataAdapter = require("./index27.cjs.js");
+const require_index = require("./index28.cjs.js");
+const require_createStorageAdapter = require("./index29.cjs.js");
+const require_createReactivityAdapter = require("./index30.cjs.js");
+const require_reactiveOrAsync = require("./index31.cjs.js");
+const require_AsyncDataAdapter = require("./index32.cjs.js");
+const require_WorkerDataAdapter = require("./index34.cjs.js");
+const require_WorkerDataAdapterHost = require("./index36.cjs.js");
+const require_AutoFetchDataAdapter = require("./index37.cjs.js");
 exports.AsyncDataAdapter = require_AsyncDataAdapter.default;
 exports.AutoFetchDataAdapter = require_AutoFetchDataAdapter.default;
 exports.Collection = require_index.default;

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export type { default as Selector } from './types/Selector';
 export type { default as Modifier } from './types/Modifier';
 export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, SortSpecifier, FieldSpecifier, AnyFindOptions, AsyncFindOptions, FindOptions, SyncFindOptions, CollectionOptions, QueryStateAccessor, } from './Collection';
 export type { default as DataAdapter } from './DataAdapter';
+export type { CollectionBackend, QueryOptions, StateChangeCallback, } from './DataAdapter';
+export type { QueryDelta } from './utils/queryDelta';
 export { default as Cursor } from './Collection/Cursor';
 export { default as Collection } from './Collection';
 export { default as createStorageAdapter } from './createStorageAdapter';