@tanstack/db 0.4.9 → 0.4.11

package/src/collection/sync.ts

@@ -1,4 +1,5 @@
 import {
+  CollectionConfigurationError,
   CollectionIsInErrorStateError,
   DuplicateKeySyncError,
   NoPendingSyncTransactionCommitError,
@@ -13,12 +14,13 @@ import type {
   ChangeMessage,
   CleanupFn,
   CollectionConfig,
-  OnLoadMoreOptions,
+  LoadSubsetOptions,
   SyncConfigRes,
 } from "../types"
 import type { CollectionImpl } from "./index.js"
 import type { CollectionStateManager } from "./state"
 import type { CollectionLifecycleManager } from "./lifecycle"
+import type { CollectionEventsManager } from "./events.js"
 
 export class CollectionSyncManager<
   TOutput extends object = Record<string, unknown>,
@@ -29,31 +31,38 @@ export class CollectionSyncManager<
   private collection!: CollectionImpl<TOutput, TKey, any, TSchema, TInput>
   private state!: CollectionStateManager<TOutput, TKey, TSchema, TInput>
   private lifecycle!: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>
+  private _events!: CollectionEventsManager
   private config!: CollectionConfig<TOutput, TKey, TSchema>
   private id: string
+  private syncMode: `eager` | `on-demand`
 
   public preloadPromise: Promise<void> | null = null
   public syncCleanupFn: (() => void) | null = null
-  public syncOnLoadMoreFn:
-    | ((options: OnLoadMoreOptions) => void | Promise<void>)
+  public syncLoadSubsetFn:
+    | ((options: LoadSubsetOptions) => true | Promise<void>)
     | null = null
 
+  private pendingLoadSubsetPromises: Set<Promise<void>> = new Set()
+
   /**
    * Creates a new CollectionSyncManager instance
    */
   constructor(config: CollectionConfig<TOutput, TKey, TSchema>, id: string) {
     this.config = config
     this.id = id
+    this.syncMode = config.syncMode ?? `eager`
   }
 
   setDeps(deps: {
     collection: CollectionImpl<TOutput, TKey, any, TSchema, TInput>
     state: CollectionStateManager<TOutput, TKey, TSchema, TInput>
     lifecycle: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>
+    events: CollectionEventsManager
   }) {
     this.collection = deps.collection
     this.state = deps.state
     this.lifecycle = deps.lifecycle
+    this._events = deps.events
   }
 
   /**
@@ -189,8 +198,16 @@ export class CollectionSyncManager<
       // Store cleanup function if provided
       this.syncCleanupFn = syncRes?.cleanup ?? null
 
-      // Store onLoadMore function if provided
-      this.syncOnLoadMoreFn = syncRes?.onLoadMore ?? null
+      // Store loadSubset function if provided
+      this.syncLoadSubsetFn = syncRes?.loadSubset ?? null
+
+      // Validate: on-demand mode requires a loadSubset function
+      if (this.syncMode === `on-demand` && !this.syncLoadSubsetFn) {
+        throw new CollectionConfigurationError(
+          `Collection "${this.id}" is configured with syncMode "on-demand" but the sync function did not return a loadSubset handler. ` +
+            `Either provide a loadSubset handler or use syncMode "eager".`
+        )
+      }
     } catch (error) {
       this.lifecycle.setStatus(`error`)
       throw error
@@ -239,16 +256,71 @@ export class CollectionSyncManager<
     return this.preloadPromise
   }
 
+  /**
+   * Gets whether the collection is currently loading more data
+   */
+  public get isLoadingSubset(): boolean {
+    return this.pendingLoadSubsetPromises.size > 0
+  }
+
+  /**
+   * Tracks a load promise for isLoadingSubset state.
+   * @internal This is for internal coordination (e.g., live-query glue code), not for general use.
+   */
+  public trackLoadPromise(promise: Promise<void>): void {
+    const loadingStarting = !this.isLoadingSubset
+    this.pendingLoadSubsetPromises.add(promise)
+
+    if (loadingStarting) {
+      this._events.emit(`loadingSubset:change`, {
+        type: `loadingSubset:change`,
+        collection: this.collection,
+        isLoadingSubset: true,
+        previousIsLoadingSubset: false,
+        loadingSubsetTransition: `start`,
+      })
+    }
+
+    promise.finally(() => {
+      const loadingEnding =
+        this.pendingLoadSubsetPromises.size === 1 &&
+        this.pendingLoadSubsetPromises.has(promise)
+      this.pendingLoadSubsetPromises.delete(promise)
+
+      if (loadingEnding) {
+        this._events.emit(`loadingSubset:change`, {
+          type: `loadingSubset:change`,
+          collection: this.collection,
+          isLoadingSubset: false,
+          previousIsLoadingSubset: true,
+          loadingSubsetTransition: `end`,
+        })
+      }
+    })
+  }
+
   /**
    * Requests the sync layer to load more data.
    * @param options Options to control what data is being loaded
    * @returns If data loading is asynchronous, this method returns a promise that resolves when the data is loaded.
-   *          If data loading is synchronous, the data is loaded when the method returns.
+   *          Returns true if no sync function is configured, if syncMode is 'eager', or if there is no work to do.
    */
-  public syncMore(options: OnLoadMoreOptions): void | Promise<void> {
-    if (this.syncOnLoadMoreFn) {
-      return this.syncOnLoadMoreFn(options)
+  public loadSubset(options: LoadSubsetOptions): Promise<void> | true {
+    // Bypass loadSubset when syncMode is 'eager'
+    if (this.syncMode === `eager`) {
+      return true
+    }
+
+    if (this.syncLoadSubsetFn) {
+      const result = this.syncLoadSubsetFn(options)
+      // If the result is a promise, track it
+      if (result instanceof Promise) {
+        this.trackLoadPromise(result)
+        return result
+      }
     }
+
+    return true
   }
 
   public cleanup(): void {

package/src/errors.ts

@@ -629,3 +629,15 @@ export class MissingAliasInputsError extends QueryCompilationError {
     )
   }
 }
+
+/**
+ * Error thrown when setWindow is called on a collection without an ORDER BY clause.
+ */
+export class SetWindowRequiresOrderByError extends QueryCompilationError {
+  constructor() {
+    super(
+      `setWindow() can only be called on collections with an ORDER BY clause. ` +
+        `Add .orderBy() to your query to enable window movement.`
+    )
+  }
+}

package/src/event-emitter.ts

@@ -0,0 +1,118 @@
+/**
+ * Generic type-safe event emitter
+ * @template TEvents - Record of event names to event payload types
+ */
+export class EventEmitter<TEvents extends Record<string, any>> {
+  private listeners = new Map<
+    keyof TEvents,
+    Set<(event: TEvents[keyof TEvents]) => void>
+  >()
+
+  /**
+   * Subscribe to an event
+   * @param event - Event name to listen for
+   * @param callback - Function to call when event is emitted
+   * @returns Unsubscribe function
+   */
+  on<T extends keyof TEvents>(
+    event: T,
+    callback: (event: TEvents[T]) => void
+  ): () => void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set())
+    }
+    this.listeners.get(event)!.add(callback as (event: any) => void)
+
+    return () => {
+      this.listeners.get(event)?.delete(callback as (event: any) => void)
+    }
+  }
+
+  /**
+   * Subscribe to an event once (automatically unsubscribes after first emission)
+   * @param event - Event name to listen for
+   * @param callback - Function to call when event is emitted
+   * @returns Unsubscribe function
+   */
+  once<T extends keyof TEvents>(
+    event: T,
+    callback: (event: TEvents[T]) => void
+  ): () => void {
+    const unsubscribe = this.on(event, (eventPayload) => {
+      callback(eventPayload)
+      unsubscribe()
+    })
+    return unsubscribe
+  }
+
+  /**
+   * Unsubscribe from an event
+   * @param event - Event name to stop listening for
+   * @param callback - Function to remove
+   */
+  off<T extends keyof TEvents>(
+    event: T,
+    callback: (event: TEvents[T]) => void
+  ): void {
+    this.listeners.get(event)?.delete(callback as (event: any) => void)
+  }
+
+  /**
+   * Wait for an event to be emitted
+   * @param event - Event name to wait for
+   * @param timeout - Optional timeout in milliseconds
+   * @returns Promise that resolves with the event payload
+   */
+  waitFor<T extends keyof TEvents>(
+    event: T,
+    timeout?: number
+  ): Promise<TEvents[T]> {
+    return new Promise((resolve, reject) => {
+      let timeoutId: NodeJS.Timeout | undefined
+      const unsubscribe = this.on(event, (eventPayload) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId)
+          timeoutId = undefined
+        }
+        resolve(eventPayload)
+        unsubscribe()
+      })
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          timeoutId = undefined
+          unsubscribe()
+          reject(new Error(`Timeout waiting for event ${String(event)}`))
+        }, timeout)
+      }
+    })
+  }
+
+  /**
+   * Emit an event to all listeners
+   * @param event - Event name to emit
+   * @param eventPayload - Event payload
+   * @internal For use by subclasses - subclasses should wrap this with a public emit if needed
+   */
+  protected emitInner<T extends keyof TEvents>(
+    event: T,
+    eventPayload: TEvents[T]
+  ): void {
+    this.listeners.get(event)?.forEach((listener) => {
+      try {
+        listener(eventPayload)
+      } catch (error) {
+        // Re-throw in a microtask to surface the error
+        queueMicrotask(() => {
+          throw error
+        })
+      }
+    })
+  }
+
+  /**
+   * Clear all listeners
+   */
+  protected clearListeners(): void {
+    this.listeners.clear()
+  }
+}

package/src/local-only.ts

@@ -1,15 +1,12 @@
 import type {
   BaseCollectionConfig,
   CollectionConfig,
-  DeleteMutationFn,
   DeleteMutationFnParams,
   InferSchemaOutput,
-  InsertMutationFn,
   InsertMutationFnParams,
   OperationType,
   PendingMutation,
   SyncConfig,
-  UpdateMutationFn,
   UpdateMutationFnParams,
   UtilsRecord,
 } from "./types"
@@ -67,13 +64,7 @@ type LocalOnlyCollectionOptionsResult<
   T extends object,
   TKey extends string | number,
   TSchema extends StandardSchemaV1 | never = never,
-> = Omit<
-  CollectionConfig<T, TKey, TSchema>,
-  `onInsert` | `onUpdate` | `onDelete`
-> & {
-  onInsert?: InsertMutationFn<T, TKey, LocalOnlyCollectionUtils>
-  onUpdate?: UpdateMutationFn<T, TKey, LocalOnlyCollectionUtils>
-  onDelete?: DeleteMutationFn<T, TKey, LocalOnlyCollectionUtils>
+> = CollectionConfig<T, TKey, TSchema> & {
   utils: LocalOnlyCollectionUtils
 }
 
@@ -191,7 +182,7 @@ export function localOnlyCollectionOptions<
   const { initialData, onInsert, onUpdate, onDelete, ...restConfig } = config
 
   // Create the sync configuration with transaction confirmation capability
-  const syncResult = createLocalOnlySync(initialData)
+  const syncResult = createLocalOnlySync<T, TKey>(initialData)
 
   /**
    * Create wrapper handlers that call user handlers first, then confirm transactions
@@ -279,9 +270,11 @@ export function localOnlyCollectionOptions<
     onDelete: wrappedOnDelete,
     utils: {
       acceptMutations,
-    } as LocalOnlyCollectionUtils,
+    },
     startSync: true,
     gcTime: 0,
+  } as LocalOnlyCollectionOptionsResult<T, TKey, TSchema> & {
+    schema?: StandardSchemaV1
   }
 }
 

package/src/query/compiler/index.ts

@@ -28,7 +28,9 @@ import type {
   NamespacedAndKeyedStream,
   ResultStream,
 } from "../../types.js"
-import type { QueryCache, QueryMapping } from "./types.js"
+import type { QueryCache, QueryMapping, WindowOptions } from "./types.js"
+
+export type { WindowOptions } from "./types.js"
 
 /**
  * Result of query compilation including both the pipeline and source-specific WHERE clauses
@@ -87,6 +89,7 @@ export function compileQuery(
   callbacks: Record<string, LazyCollectionCallbacks>,
   lazySources: Set<string>,
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
+  setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   cache: QueryCache = new WeakMap(),
   queryMapping: QueryMapping = new WeakMap()
 ): CompilationResult {
@@ -134,6 +137,7 @@ export function compileQuery(
     callbacks,
     lazySources,
     optimizableOrderByCollections,
+    setWindowFn,
     cache,
     queryMapping,
     aliasToCollectionId,
@@ -169,6 +173,7 @@ export function compileQuery(
       callbacks,
       lazySources,
       optimizableOrderByCollections,
+      setWindowFn,
       rawQuery,
       compileQuery,
       aliasToCollectionId,
@@ -311,6 +316,7 @@ export function compileQuery(
       query.select || {},
       collections[mainCollectionId]!,
       optimizableOrderByCollections,
+      setWindowFn,
       query.limit,
       query.offset
     )
@@ -381,6 +387,7 @@ function processFrom(
   callbacks: Record<string, LazyCollectionCallbacks>,
   lazySources: Set<string>,
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
+  setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   cache: QueryCache,
   queryMapping: QueryMapping,
   aliasToCollectionId: Record<string, string>,
@@ -412,6 +419,7 @@ function processFrom(
         callbacks,
         lazySources,
         optimizableOrderByCollections,
+        setWindowFn,
         cache,
         queryMapping
       )

package/src/query/compiler/joins.ts

@@ -31,7 +31,7 @@ import type {
   NamespacedAndKeyedStream,
   NamespacedRow,
 } from "../../types.js"
-import type { QueryCache, QueryMapping } from "./types.js"
+import type { QueryCache, QueryMapping, WindowOptions } from "./types.js"
 import type { CollectionSubscription } from "../../collection/subscription.js"
 
 /** Function type for loading specific keys into a lazy collection */
@@ -61,6 +61,7 @@ export function processJoins(
   callbacks: Record<string, LazyCollectionCallbacks>,
   lazySources: Set<string>,
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
+  setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   rawQuery: QueryIR,
   onCompileSubquery: CompileQueryFn,
   aliasToCollectionId: Record<string, string>,
@@ -83,6 +84,7 @@ export function processJoins(
       callbacks,
       lazySources,
       optimizableOrderByCollections,
+      setWindowFn,
       rawQuery,
       onCompileSubquery,
       aliasToCollectionId,
@@ -111,6 +113,7 @@ function processJoin(
   callbacks: Record<string, LazyCollectionCallbacks>,
   lazySources: Set<string>,
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
+  setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   rawQuery: QueryIR,
   onCompileSubquery: CompileQueryFn,
   aliasToCollectionId: Record<string, string>,
@@ -131,6 +134,7 @@ function processJoin(
     callbacks,
     lazySources,
     optimizableOrderByCollections,
+    setWindowFn,
     cache,
     queryMapping,
     onCompileSubquery,
@@ -421,6 +425,7 @@ function processJoinSource(
   callbacks: Record<string, LazyCollectionCallbacks>,
   lazySources: Set<string>,
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
+  setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   cache: QueryCache,
   queryMapping: QueryMapping,
   onCompileSubquery: CompileQueryFn,
@@ -453,6 +458,7 @@ function processJoinSource(
         callbacks,
         lazySources,
         optimizableOrderByCollections,
+        setWindowFn,
         cache,
         queryMapping
       )

package/src/query/compiler/order-by.ts

@@ -5,6 +5,7 @@ import { ensureIndexForField } from "../../indexes/auto-index.js"
 import { findIndexForField } from "../../utils/index-optimization.js"
 import { compileExpression } from "./evaluators.js"
 import { replaceAggregatesByRefs } from "./group-by.js"
+import type { WindowOptions } from "./types.js"
 import type { CompiledSingleRowExpression } from "./evaluators.js"
 import type { OrderBy, OrderByClause, QueryIR, Select } from "../ir.js"
 import type { NamespacedAndKeyedStream, NamespacedRow } from "../../types.js"
@@ -38,6 +39,7 @@ export function processOrderBy(
   selectClause: Select,
   collection: Collection,
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
+  setWindowFn: (windowFn: (options: WindowOptions) => void) => void,
   limit?: number,
   offset?: number
 ): IStreamBuilder<KeyValue<unknown, [NamespacedRow, string]>> {
@@ -107,6 +109,8 @@ export function processOrderBy(
 
   let setSizeCallback: ((getSize: () => number) => void) | undefined
 
+  let orderByOptimizationInfo: OrderByOptimizationInfo | undefined
+
   // Optimize the orderBy operator to lazily load elements
   // by using the range index of the collection.
   // Only for orderBy clause on a single column for now (no composite ordering)
@@ -161,7 +165,7 @@ export function processOrderBy(
             ? String(orderByExpression.path[0])
             : rawQuery.from.alias
 
-        const orderByOptimizationInfo = {
+        orderByOptimizationInfo = {
           alias: orderByAlias,
           offset: offset ?? 0,
           limit,
@@ -179,7 +183,7 @@ export function processOrderBy(
             ...optimizableOrderByCollections[followRefCollection.id]!,
             dataNeeded: () => {
               const size = getSize()
-              return Math.max(0, limit - size)
+              return Math.max(0, orderByOptimizationInfo!.limit - size)
             },
           }
         }
@@ -194,6 +198,23 @@ export function processOrderBy(
       offset,
       comparator: compare,
       setSizeCallback,
+      setWindowFn: (
+        windowFn: (options: { offset?: number; limit?: number }) => void
+      ) => {
+        setWindowFn(
+          // We wrap the move function such that we update the orderByOptimizationInfo
+          // because that is used by the `dataNeeded` callback to determine if we need to load more data
+          (options) => {
+            windowFn(options)
+            if (orderByOptimizationInfo) {
+              orderByOptimizationInfo.offset =
+                options.offset ?? orderByOptimizationInfo.offset
+              orderByOptimizationInfo.limit =
+                options.limit ?? orderByOptimizationInfo.limit
+            }
+          }
+        )
+      },
     })
     // orderByWithFractionalIndex returns [key, [value, index]] - we keep this format
   )

package/src/query/compiler/types.ts

@@ -10,3 +10,8 @@ export type QueryCache = WeakMap<QueryIR, CompilationResult>
  * Mapping from optimized queries back to their original queries for caching
  */
 export type QueryMapping = WeakMap<QueryIR, QueryIR>
+
+export type WindowOptions = {
+  offset?: number
+  limit?: number
+}

package/src/query/index.ts

@@ -56,3 +56,4 @@ export {
 } from "./live-query-collection.js"
 
 export { type LiveQueryCollectionConfig } from "./live/types.js"
+export { type LiveQueryCollectionUtils } from "./live/collection-config-builder.js"

package/src/query/live/collection-config-builder.ts

@@ -1,11 +1,15 @@
 import { D2, output } from "@tanstack/db-ivm"
 import { compileQuery } from "../compiler/index.js"
 import { buildQuery, getQueryIR } from "../builder/index.js"
-import { MissingAliasInputsError } from "../../errors.js"
+import {
+  MissingAliasInputsError,
+  SetWindowRequiresOrderByError,
+} from "../../errors.js"
 import { transactionScopedScheduler } from "../../scheduler.js"
 import { getActiveTransaction } from "../../transactions.js"
 import { CollectionSubscriber } from "./collection-subscriber.js"
 import { getCollectionBuilder } from "./collection-registry.js"
+import type { WindowOptions } from "../compiler/index.js"
 import type { SchedulerContextId } from "../../scheduler.js"
 import type { CollectionSubscription } from "../../collection/subscription.js"
 import type { RootStreamBuilder } from "@tanstack/db-ivm"
@@ -32,6 +36,19 @@ import type { AllCollectionEvents } from "../../collection/events.js"
 export type LiveQueryCollectionUtils = UtilsRecord & {
   getRunCount: () => number
   getBuilder: () => CollectionConfigBuilder<any, any>
+  /**
+   * Sets the offset and limit of an ordered query.
+   * Is a no-op if the query is not ordered.
+   *
+   * @returns `true` if no subset loading was triggered, or `Promise<void>` that resolves when the subset has been loaded
+   */
+  setWindow: (options: WindowOptions) => true | Promise<void>
+  /**
+   * Gets the current window (offset and limit) for an ordered query.
+   *
+   * @returns The current window settings, or `undefined` if the query is not windowed
+   */
+  getWindow: () => { offset: number; limit: number } | undefined
 }
 
 type PendingGraphRun = {
@@ -79,7 +96,12 @@ export class CollectionConfigBuilder<
   private isInErrorState = false
 
   // Reference to the live query collection for error state transitions
-  private liveQueryCollection?: Collection<TResult, any, any>
+  public liveQueryCollection?: Collection<TResult, any, any>
+
+  private windowFn: ((options: WindowOptions) => void) | undefined
+  private currentWindow: WindowOptions | undefined
+
+  private maybeRunGraphFn: (() => void) | undefined
 
   private readonly aliasDependencies: Record<
     string,
@@ -171,10 +193,52 @@ export class CollectionConfigBuilder<
       utils: {
         getRunCount: this.getRunCount.bind(this),
         getBuilder: () => this,
+        setWindow: this.setWindow.bind(this),
+        getWindow: this.getWindow.bind(this),
       },
     }
   }
 
+  setWindow(options: WindowOptions): true | Promise<void> {
+    if (!this.windowFn) {
+      throw new SetWindowRequiresOrderByError()
+    }
+
+    this.currentWindow = options
+    this.windowFn(options)
+    this.maybeRunGraphFn?.()
+
+    // Check if loading a subset was triggered
+    if (this.liveQueryCollection?.isLoadingSubset) {
+      // Loading was triggered, return a promise that resolves when it completes
+      return new Promise<void>((resolve) => {
+        const unsubscribe = this.liveQueryCollection!.on(
+          `loadingSubset:change`,
+          (event) => {
+            if (!event.isLoadingSubset) {
+              unsubscribe()
+              resolve()
+            }
+          }
+        )
+      })
+    }
+
+    // No loading was triggered
+    return true
+  }
+
+  getWindow(): { offset: number; limit: number } | undefined {
+    // Only return window if this is a windowed query (has orderBy and windowFn)
+    if (!this.windowFn || !this.currentWindow) {
+      return undefined
+    }
+    return {
+      offset: this.currentWindow.offset ?? 0,
+      limit: this.currentWindow.limit ?? 0,
+    }
+  }
+
   /**
    * Resolves a collection alias to its collection ID.
    *
@@ -452,13 +516,15 @@ export class CollectionConfigBuilder<
       }
     )
 
-    const loadMoreDataCallbacks = this.subscribeToAllCollections(
+    const loadSubsetDataCallbacks = this.subscribeToAllCollections(
       config,
       fullSyncState
     )
 
+    this.maybeRunGraphFn = () => this.scheduleGraphRun(loadSubsetDataCallbacks)
+
     // Initial run with callback to load more data if needed
-    this.scheduleGraphRun(loadMoreDataCallbacks)
+    this.scheduleGraphRun(loadSubsetDataCallbacks)
 
     // Return the unsubscribe function
     return () => {
@@ -517,7 +583,10 @@ export class CollectionConfigBuilder<
       this.subscriptions,
       this.lazySourcesCallbacks,
       this.lazySources,
-      this.optimizableOrderByCollections
+      this.optimizableOrderByCollections,
+      (windowFn: (options: WindowOptions) => void) => {
+        this.windowFn = windowFn
+      }
     )
 
     this.pipelineCache = compilation.pipeline
@@ -764,7 +833,7 @@ export class CollectionConfigBuilder<
     // Combine all loaders into a single callback that initiates loading more data
     // from any source that needs it. Returns true once all loaders have been called,
     // but the actual async loading may still be in progress.
-    const loadMoreDataCallback = () => {
+    const loadSubsetDataCallbacks = () => {
       loaders.map((loader) => loader())
       return true
     }
@@ -776,7 +845,7 @@ export class CollectionConfigBuilder<
     // Initial status check after all subscriptions are set up
     this.updateLiveQueryStatus(config)
 
-    return loadMoreDataCallback
+    return loadSubsetDataCallbacks
   }
 }