@fuma-content/studio 1.0.3 → 1.0.4

package/build/server/__ssr_build/assets/{spinner-w3Q_wkh3.js → select-B8QQSB6X.js}

@@ -1,12 +1,13 @@
-import { r as reactExports, j as jsxRuntimeExports, i as reactDomExports } from "../index.js";
-import { c as createLucideIcon, j as createPopperScope, h as useControllableState, R as Root2$1, a as createContextScope, k as useId, u as useComposedRefs, A as Anchor, P as Primitive, b as composeEventHandlers, f as useLayoutEffect2, l as Portal$1, V as VISUALLY_HIDDEN_STYLES, e as useCallbackRef, m as hideOthers, p as useFocusGuards, n as ReactRemoveScroll, o as createSlot, F as FocusScope, D as DismissableLayer, C as Content, q as Arrow, s as cn } from "./button-U-KvP9zg.js";
-import { u as useDirection, a as createCollection, C as Check } from "./index-BloUStie.js";
-const __iconNode$2 = [["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]];
-const ChevronDown = createLucideIcon("chevron-down", __iconNode$2);
-const __iconNode$1 = [["path", { d: "m18 15-6-6-6 6", key: "153udz" }]];
-const ChevronUp = createLucideIcon("chevron-up", __iconNode$1);
-const __iconNode = [["path", { d: "M21 12a9 9 0 1 1-6.219-8.56", key: "13zald" }]];
-const LoaderCircle = createLucideIcon("loader-circle", __iconNode);
+import { r as reactExports, j as jsxRuntimeExports, h as reactDomExports } from "../index.js";
+import { c as createLucideIcon, f as useControllableState, R as Root2$1, u as useId, m as useComposedRefs, A as Anchor, P as Primitive, g as composeEventHandlers, e as useLayoutEffect2, s as Portal$1, t as createPopperScope, V as VISUALLY_HIDDEN_STYLES, d as useCallbackRef, v as hideOthers, y as useFocusGuards, w as ReactRemoveScroll, F as FocusScope, D as DismissableLayer, h as createContextScope, x as createSlot, z as Content, E as Arrow, b as cn } from "./index-By9m5mBe.js";
+import { u as useDirection, c as createCollection, C as Check } from "./index-BPd5y8T-.js";
+const __iconNode$1 = [["path", { d: "m6 9 6 6 6-6", key: "qrunsl" }]];
+const ChevronDown = createLucideIcon("chevron-down", __iconNode$1);
+const __iconNode = [["path", { d: "m18 15-6-6-6 6", key: "153udz" }]];
+const ChevronUp = createLucideIcon("chevron-up", __iconNode);
+function clamp(value, [min, max]) {
+  return Math.min(max, Math.max(min, value));
+}
 function usePrevious(value) {
   const ref = reactExports.useRef({ value, previous: value });
   return reactExports.useMemo(() => {
@@ -17,9 +18,6 @@ function usePrevious(value) {
     return ref.current.previous;
   }, [value]);
 }
-function clamp(value, [min, max]) {
-  return Math.min(max, Math.max(min, value));
-}
 var OPEN_KEYS = [" ", "Enter", "ArrowUp", "ArrowDown"];
 var SELECTION_KEYS = [" ", "Enter"];
 var SELECT_NAME = "Select";
@@ -1267,25 +1265,12 @@ function SelectScrollDownButton({
     }
   );
 }
-function Spinner({ className, ...props }) {
-  return /* @__PURE__ */ jsxRuntimeExports.jsx(
-    LoaderCircle,
-    {
-      role: "status",
-      "aria-label": "Loading",
-      className: cn("size-4 animate-spin", className),
-      ...props
-    }
-  );
-}
 export {
   ChevronDown as C,
-  LoaderCircle as L,
   Select as S,
   SelectTrigger as a,
   SelectValue as b,
   SelectContent as c,
   SelectItem as d,
-  Spinner as e,
   usePrevious as u
 };

package/build/server/__ssr_build/assets/{separator-CKrKBtv4.js → separator-C601eKPH.js}

@@ -1,5 +1,6 @@
 import { r as reactExports, j as jsxRuntimeExports } from "../index.js";
-import { P as Primitive, s as cn } from "./button-U-KvP9zg.js";
+import { P as Primitive } from "./index-Ch7b9Ofo.js";
+import { b as cn } from "./index-By9m5mBe.js";
 var NAME = "Separator";
 var DEFAULT_ORIENTATION = "horizontal";
 var ORIENTATIONS = ["horizontal", "vertical"];
@@ -44,6 +45,5 @@ function Separator({
   );
 }
 export {
-  Root as R,
   Separator as S
 };

package/build/server/__ssr_build/assets/{sidebar-DoXmiwf0.js → sidebar-C6fHDjcx.js}

@@ -1,9 +1,9 @@
-import { r as reactExports, c as createServerReference, j as jsxRuntimeExports } from "../index.js";
+import { r as reactExports, d as createServerReference, j as jsxRuntimeExports } from "../index.js";
 import { queryCollectionOptions } from "@tanstack/query-db-collection";
 import { q as queryClient } from "./query-C1_xUNXy.js";
 import { cva } from "class-variance-authority";
-import { c as createLucideIcon, s as cn, B as Button, X, S as Slot } from "./button-U-KvP9zg.js";
-import { R as Root, C as Content, a as Close, T as Title, D as Description, P as Portal, O as Overlay, l as Tooltip, m as TooltipTrigger, q as TooltipContent } from "./tooltip-B2NV0tpS.js";
+import { c as createLucideIcon, B as Button, X, b as cn, S as Slot } from "./index-By9m5mBe.js";
+import { R as Root, C as Content, ao as Close, am as Title, an as Description, P as Portal, O as Overlay, T as Tooltip, i as TooltipTrigger, m as TooltipContent } from "./tooltip-B3A57zPO.js";
 const __iconNode = [
   ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
   ["path", { d: "M9 3v18", key: "fh3hqa" }]
@@ -655,6 +655,7 @@ function areUint8ArraysEqual(a, b) {
   return true;
 }
 const UINT8ARRAY_NORMALIZE_THRESHOLD = 128;
+const UNDEFINED_SENTINEL = `__TS_DB_BTREE_UNDEFINED_VALUE__`;
 function normalizeValue(value) {
   if (value instanceof Date) {
     return value.getTime();
@@ -667,6 +668,18 @@ function normalizeValue(value) {
   }
   return value;
 }
+function normalizeForBTree(value) {
+  if (value === void 0) {
+    return UNDEFINED_SENTINEL;
+  }
+  return normalizeValue(value);
+}
+function denormalizeUndefined(value) {
+  if (value === UNDEFINED_SENTINEL) {
+    return void 0;
+  }
+  return value;
+}
 function areValuesEqual(a, b) {
   if (a === b) {
     return true;
@@ -1196,9 +1209,15 @@ class ReverseIndex {
   take(n, from, filterFn) {
     return this.originalIndex.takeReversed(n, from, filterFn);
   }
+  takeFromStart(n, filterFn) {
+    return this.originalIndex.takeReversedFromEnd(n, filterFn);
+  }
   takeReversed(n, from, filterFn) {
     return this.originalIndex.take(n, from, filterFn);
   }
+  takeReversedFromEnd(n, filterFn) {
+    return this.originalIndex.takeFromStart(n, filterFn);
+  }
   get orderedEntriesArray() {
     return this.originalIndex.orderedEntriesArrayReversed;
   }
@@ -4536,7 +4555,8 @@ class BTreeIndex extends BaseIndex {
     this.valueMap = /* @__PURE__ */ new Map();
     this.indexedKeys = /* @__PURE__ */ new Set();
     this.compareFn = defaultComparator;
-    this.compareFn = options?.compareFn ?? defaultComparator;
+    const baseCompareFn = options?.compareFn ?? defaultComparator;
+    this.compareFn = (a, b) => baseCompareFn(denormalizeUndefined(a), denormalizeUndefined(b));
     if (options?.compareOptions) {
       this.compareOptions = options.compareOptions;
     }
@@ -4556,7 +4576,7 @@ class BTreeIndex extends BaseIndex {
         `Failed to evaluate index expression for key ${key}: ${error}`
       );
     }
-    const normalizedValue = normalizeValue(indexedValue2);
+    const normalizedValue = normalizeForBTree(indexedValue2);
     if (this.valueMap.has(normalizedValue)) {
       this.valueMap.get(normalizedValue).add(key);
     } else {
@@ -4581,7 +4601,7 @@ class BTreeIndex extends BaseIndex {
       );
       return;
     }
-    const normalizedValue = normalizeValue(indexedValue2);
+    const normalizedValue = normalizeForBTree(indexedValue2);
     if (this.valueMap.has(normalizedValue)) {
       const keySet = this.valueMap.get(normalizedValue);
       keySet.delete(key);
@@ -4660,7 +4680,7 @@ class BTreeIndex extends BaseIndex {
    * Performs an equality lookup
    */
   equalityLookup(value) {
-    const normalizedValue = normalizeValue(value);
+    const normalizedValue = normalizeForBTree(value);
     return new Set(this.valueMap.get(normalizedValue) ?? []);
   }
   /**
@@ -4670,10 +4690,10 @@ class BTreeIndex extends BaseIndex {
   rangeQuery(options = {}) {
     const { from, to, fromInclusive = true, toInclusive = true } = options;
     const result = /* @__PURE__ */ new Set();
-    const normalizedFrom = normalizeValue(from);
-    const normalizedTo = normalizeValue(to);
-    const fromKey = normalizedFrom ?? this.orderedEntries.minKey();
-    const toKey = normalizedTo ?? this.orderedEntries.maxKey();
+    const hasFrom = `from` in options;
+    const hasTo = `to` in options;
+    const fromKey = hasFrom ? normalizeForBTree(from) : this.orderedEntries.minKey();
+    const toKey = hasTo ? normalizeForBTree(to) : this.orderedEntries.maxKey();
     this.orderedEntries.forRange(
       fromKey,
       toKey,
@@ -4695,18 +4715,28 @@ class BTreeIndex extends BaseIndex {
    */
   rangeQueryReversed(options = {}) {
     const { from, to, fromInclusive = true, toInclusive = true } = options;
+    const hasFrom = `from` in options;
+    const hasTo = `to` in options;
     return this.rangeQuery({
-      from: to ?? this.orderedEntries.maxKey(),
-      to: from ?? this.orderedEntries.minKey(),
+      from: hasTo ? to : this.orderedEntries.maxKey(),
+      to: hasFrom ? from : this.orderedEntries.minKey(),
       fromInclusive: toInclusive,
       toInclusive: fromInclusive
     });
   }
+  /**
+   * Internal method for taking items from the index.
+   * @param n - The number of items to return
+   * @param nextPair - Function to get the next pair from the BTree
+   * @param from - Already normalized! undefined means "start from beginning/end", sentinel means "start from the key undefined"
+   * @param filterFn - Optional filter function
+   * @param reversed - Whether to reverse the order of keys within each value
+   */
   takeInternal(n, nextPair, from, filterFn, reversed = false) {
     const keysInResult = /* @__PURE__ */ new Set();
     const result = [];
     let pair;
-    let key = normalizeValue(from);
+    let key = from;
     while ((pair = nextPair(key)) !== void 0 && result.length < n) {
       key = pair[0];
       const keys = this.valueMap.get(key);
@@ -4725,24 +4755,46 @@ class BTreeIndex extends BaseIndex {
     return result;
   }
   /**
-   * Returns the next n items after the provided item or the first n items if no from item is provided.
+   * Returns the next n items after the provided item.
    * @param n - The number of items to return
-   * @param from - The item to start from (exclusive). Starts from the smallest item (inclusive) if not provided.
-   * @returns The next n items after the provided key. Returns the first n items if no from item is provided.
+   * @param from - The item to start from (exclusive).
+   * @returns The next n items after the provided key.
    */
   take(n, from, filterFn) {
     const nextPair = (k) => this.orderedEntries.nextHigherPair(k);
-    return this.takeInternal(n, nextPair, from, filterFn);
+    const normalizedFrom = normalizeForBTree(from);
+    return this.takeInternal(n, nextPair, normalizedFrom, filterFn);
+  }
+  /**
+   * Returns the first n items from the beginning.
+   * @param n - The number of items to return
+   * @param filterFn - Optional filter function
+   * @returns The first n items
+   */
+  takeFromStart(n, filterFn) {
+    const nextPair = (k) => this.orderedEntries.nextHigherPair(k);
+    return this.takeInternal(n, nextPair, void 0, filterFn);
   }
   /**
-   * Returns the next n items **before** the provided item (in descending order) or the last n items if no from item is provided.
+   * Returns the next n items **before** the provided item (in descending order).
    * @param n - The number of items to return
-   * @param from - The item to start from (exclusive). Starts from the largest item (inclusive) if not provided.
-   * @returns The next n items **before** the provided key. Returns the last n items if no from item is provided.
+   * @param from - The item to start from (exclusive). Required.
+   * @returns The next n items **before** the provided key.
    */
   takeReversed(n, from, filterFn) {
     const nextPair = (k) => this.orderedEntries.nextLowerPair(k);
-    return this.takeInternal(n, nextPair, from, filterFn, true);
+    const normalizedFrom = normalizeForBTree(from);
+    return this.takeInternal(n, nextPair, normalizedFrom, filterFn, true);
+  }
+  /**
+   * Returns the last n items from the end.
+   * @param n - The number of items to return
+   * @param filterFn - Optional filter function
+   * @returns The last n items
+   */
+  takeReversedFromEnd(n, filterFn) {
+    const nextPair = (k) => this.orderedEntries.nextLowerPair(k);
+    return this.takeInternal(n, nextPair, void 0, filterFn, true);
   }
   /**
    * Performs an IN array lookup
@@ -4750,7 +4802,7 @@ class BTreeIndex extends BaseIndex {
   inArrayLookup(values) {
     const result = /* @__PURE__ */ new Set();
     for (const value of values) {
-      const normalizedValue = normalizeValue(value);
+      const normalizedValue = normalizeForBTree(value);
       const keys = this.valueMap.get(normalizedValue);
       if (keys) {
         keys.forEach((key) => result.add(key));
@@ -4763,16 +4815,23 @@ class BTreeIndex extends BaseIndex {
     return this.indexedKeys;
   }
   get orderedEntriesArray() {
-    return this.orderedEntries.keysArray().map((key) => [key, this.valueMap.get(key) ?? /* @__PURE__ */ new Set()]);
+    return this.orderedEntries.keysArray().map((key) => [
+      denormalizeUndefined(key),
+      this.valueMap.get(key) ?? /* @__PURE__ */ new Set()
+    ]);
   }
   get orderedEntriesArrayReversed() {
-    return this.takeReversed(this.orderedEntries.size).map((key) => [
-      key,
+    return this.takeReversedFromEnd(this.orderedEntries.size).map((key) => [
+      denormalizeUndefined(key),
       this.valueMap.get(key) ?? /* @__PURE__ */ new Set()
     ]);
   }
   get valueMapData() {
-    return this.valueMap;
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, value] of this.valueMap) {
+      result.set(denormalizeUndefined(key), value);
+    }
+    return result;
   }
 }
 function shouldAutoIndex(collection2) {
@@ -5467,7 +5526,7 @@ function getOrderedKeys(collection2, orderBy, limit, whereFilter, optimizedOnly)
           }
           return whereFilter?.(value) ?? true;
         };
-        return index.take(limit ?? index.keyCount, void 0, filterFn);
+        return index.takeFromStart(limit ?? index.keyCount, filterFn);
       }
     }
   }
@@ -6604,6 +6663,7 @@ class CollectionSubscription extends EventEmitter {
       limit: opts?.limit
     };
     const syncResult = this.collection._sync.loadSubset(loadOptions);
+    opts?.onLoadSubsetResult?.(syncResult);
     this.loadedSubsets.push(loadOptions);
     const trackLoadSubsetPromise = opts?.trackLoadSubsetPromise ?? true;
     if (trackLoadSubsetPromise) {
@@ -6640,7 +6700,9 @@ class CollectionSubscription extends EventEmitter {
     orderBy,
     limit,
     minValues,
-    offset
+    offset,
+    trackLoadSubsetPromise: shouldTrackLoadSubsetPromise = true,
+    onLoadSubsetResult
   }) {
     if (!limit) throw new Error(`limit is required`);
     if (!this.orderByIndex) {
@@ -6648,13 +6710,14 @@ class CollectionSubscription extends EventEmitter {
         `Ordered snapshot was requested but no index was found. You have to call setOrderByIndex before requesting an ordered snapshot.`
       );
     }
+    const hasMinValue = minValues !== void 0 && minValues.length > 0;
     const minValue = minValues?.[0];
     const minValueForIndex = minValue;
     const index = this.orderByIndex;
     const where = this.options.whereExpression;
     const whereFilterFn = where ? createFilterFunctionFromExpression(where) : void 0;
     const filterFn = (key) => {
-      if (this.sentKeys.has(key)) {
+      if (key !== void 0 && this.sentKeys.has(key)) {
         return false;
       }
       const value = this.collection.get(key);
@@ -6666,7 +6729,7 @@ class CollectionSubscription extends EventEmitter {
     let biggestObservedValue = minValueForIndex;
     const changes = [];
     let keys = [];
-    if (minValueForIndex !== void 0) {
+    if (hasMinValue) {
       const { expression } = orderBy[0];
       const allRowsWithMinValue = this.collection.currentStateAsChanges({
         where: eq(expression, new Value(minValueForIndex))
@@ -6684,7 +6747,7 @@ class CollectionSubscription extends EventEmitter {
         keys = index.take(limit, minValueForIndex, filterFn);
       }
     } else {
-      keys = index.take(limit, minValueForIndex, filterFn);
+      keys = index.takeFromStart(limit, filterFn);
     }
     const valuesNeeded = () => Math.max(limit - changes.length, 0);
     const collectionExhausted = () => keys.length === 0;
@@ -6748,8 +6811,11 @@ class CollectionSubscription extends EventEmitter {
       subscription: this
     };
     const syncResult = this.collection._sync.loadSubset(loadOptions);
+    onLoadSubsetResult?.(syncResult);
     this.loadedSubsets.push(loadOptions);
-    this.trackLoadSubsetPromise(syncResult);
+    if (shouldTrackLoadSubsetPromise) {
+      this.trackLoadSubsetPromise(syncResult);
+    }
   }
   // TODO: also add similar test but that checks that it can also load it from the collection's loadSubset function
   //       and that that also works properly (i.e. does not skip duplicate values)
@@ -6799,6 +6865,12 @@ class CollectionSubscription extends EventEmitter {
         this.sentKeys.add(change.key);
       }
     }
+    if (this.orderByIndex) {
+      this.limitedSnapshotRowCount = Math.max(
+        this.limitedSnapshotRowCount,
+        this.sentKeys.size
+      );
+    }
   }
   /**
    * Mark that the subscription should not filter any changes.
@@ -6902,7 +6974,12 @@ class CollectionChangesManager {
       subscription.on(`status:change`, options.onStatusChange);
     }
     if (options.includeInitialState) {
-      subscription.requestSnapshot({ trackLoadSubsetPromise: false });
+      subscription.requestSnapshot({
+        trackLoadSubsetPromise: false,
+        orderBy: options.orderBy,
+        limit: options.limit,
+        onLoadSubsetResult: options.onLoadSubsetResult
+      });
     } else if (options.includeInitialState === false) {
       subscription.markAllStateAsSeen();
     }
@@ -7135,7 +7212,18 @@ class CollectionLifecycleManager {
         this.gcTimeoutId = null;
       }
       this.hasBeenReady = false;
+      const callbacks = [...this.onFirstReadyCallbacks];
       this.onFirstReadyCallbacks = [];
+      callbacks.forEach((callback) => {
+        try {
+          callback();
+        } catch (error) {
+          console.error(
+            `${this.config.id ? `[${this.config.id}] ` : ``}Error in onFirstReady callback during cleanup:`,
+            error
+          );
+        }
+      });
       this.setStatus(`cleaned-up`);
       this.events.cleanup();
       return true;
@@ -11597,24 +11685,17 @@ class CollectionSubscriber {
   }
   subscribeToChanges(whereExpression) {
     const orderByInfo = this.getOrderByInfo();
-    const trackLoadPromise = (subscription2) => {
-      if (!this.subscriptionLoadingPromises.has(subscription2)) {
-        let resolve;
-        const promise = new Promise((res) => {
-          resolve = res;
-        });
-        this.subscriptionLoadingPromises.set(subscription2, {
-          resolve
-        });
+    const trackLoadResult = (result) => {
+      if (result instanceof Promise) {
         this.collectionConfigBuilder.liveQueryCollection._sync.trackLoadPromise(
-          promise
+          result
         );
       }
     };
     const onStatusChange = (event) => {
       const subscription2 = event.subscription;
       if (event.status === `loadingSubset`) {
-        trackLoadPromise(subscription2);
+        this.ensureLoadingPromise(subscription2);
       } else {
         const deferred = this.subscriptionLoadingPromises.get(subscription2);
         if (deferred) {
@@ -11628,7 +11709,8 @@ class CollectionSubscriber {
       subscription = this.subscribeToOrderedChanges(
         whereExpression,
         orderByInfo,
-        onStatusChange
+        onStatusChange,
+        trackLoadResult
       );
     } else {
       const includeInitialState = !this.collectionConfigBuilder.isLazyAlias(
@@ -11641,7 +11723,7 @@ class CollectionSubscriber {
       );
     }
     if (subscription.status === `loadingSubset`) {
-      trackLoadPromise(subscription);
+      this.ensureLoadingPromise(subscription);
     }
     const unsubscribe = () => {
       const deferred = this.subscriptionLoadingPromises.get(subscription);
@@ -11685,18 +11767,55 @@ class CollectionSubscriber {
     const sendChanges = (changes) => {
       this.sendChangesToPipeline(changes);
     };
+    const { orderBy, limit, offset } = this.collectionConfigBuilder.query;
+    const effectiveLimit = limit !== void 0 && offset !== void 0 ? limit + offset : limit;
+    const normalizedOrderBy = orderBy ? normalizeOrderByPaths(orderBy, this.alias) : void 0;
+    const canPassOrderBy = normalizedOrderBy?.every((clause) => {
+      const exp = clause.expression;
+      if (exp.type !== `ref`) {
+        return false;
+      }
+      const path = exp.path;
+      return Array.isArray(path) && path.length === 1;
+    }) ?? false;
+    const orderByForSubscription = canPassOrderBy ? normalizedOrderBy : void 0;
+    const limitForSubscription = canPassOrderBy ? effectiveLimit : void 0;
+    const onLoadSubsetResult = includeInitialState ? (result) => {
+      if (result instanceof Promise) {
+        this.collectionConfigBuilder.liveQueryCollection._sync.trackLoadPromise(
+          result
+        );
+      }
+    } : void 0;
     const subscription = this.collection.subscribeChanges(sendChanges, {
       ...includeInitialState && { includeInitialState },
       whereExpression,
-      onStatusChange
+      onStatusChange,
+      orderBy: orderByForSubscription,
+      limit: limitForSubscription,
+      onLoadSubsetResult
     });
     return subscription;
   }
-  subscribeToOrderedChanges(whereExpression, orderByInfo, onStatusChange) {
+  subscribeToOrderedChanges(whereExpression, orderByInfo, onStatusChange, onLoadSubsetResult) {
     const { orderBy, offset, limit, index } = orderByInfo;
+    const handleLoadSubsetResult = (result) => {
+      if (result instanceof Promise) {
+        this.pendingOrderedLoadPromise = result;
+        result.finally(() => {
+          if (this.pendingOrderedLoadPromise === result) {
+            this.pendingOrderedLoadPromise = void 0;
+          }
+        });
+      }
+      onLoadSubsetResult(result);
+    };
+    this.orderedLoadSubsetResult = handleLoadSubsetResult;
     const subscriptionHolder = {};
     const sendChangesInRange = (changes) => {
-      const splittedChanges = splitUpdates(changes);
+      const changesArray = Array.isArray(changes) ? changes : [...changes];
+      this.trackSentValues(changesArray, orderByInfo.comparator);
+      const splittedChanges = splitUpdates(changesArray);
       this.sendChangesToPipelineWithTracking(
         splittedChanges,
         subscriptionHolder.current
@@ -11709,6 +11828,8 @@ class CollectionSubscriber {
     subscriptionHolder.current = subscription;
     const truncateUnsubscribe = this.collection.on(`truncate`, () => {
       this.biggest = void 0;
+      this.lastLoadRequestKey = void 0;
+      this.pendingOrderedLoadPromise = void 0;
       this.sentToD2Keys.clear();
     });
     subscription.on(`unsubscribed`, () => {
@@ -11719,12 +11840,16 @@ class CollectionSubscriber {
       subscription.setOrderByIndex(index);
       subscription.requestLimitedSnapshot({
         limit: offset + limit,
-        orderBy: normalizedOrderBy
+        orderBy: normalizedOrderBy,
+        trackLoadSubsetPromise: false,
+        onLoadSubsetResult: handleLoadSubsetResult
       });
     } else {
       subscription.requestSnapshot({
         orderBy: normalizedOrderBy,
-        limit: offset + limit
+        limit: offset + limit,
+        trackLoadSubsetPromise: false,
+        onLoadSubsetResult: handleLoadSubsetResult
       });
     }
     return subscription;
@@ -11741,6 +11866,9 @@ class CollectionSubscriber {
     if (!dataNeeded) {
       return true;
     }
+    if (this.pendingOrderedLoadPromise) {
+      return true;
+    }
     const n = dataNeeded();
     if (n > 0) {
       this.loadNextItems(n, subscription);
@@ -11753,11 +11881,10 @@ class CollectionSubscriber {
       this.sendChangesToPipeline(changes);
       return;
     }
-    const trackedChanges = this.trackSentValues(changes, orderByInfo.comparator);
     const subscriptionWithLoader = subscription;
     subscriptionWithLoader[loadMoreCallbackSymbol] ??= this.loadMoreIfNeeded.bind(this, subscription);
     this.sendChangesToPipeline(
-      trackedChanges,
+      changes,
       subscriptionWithLoader[loadMoreCallbackSymbol]
     );
   }
@@ -11771,14 +11898,29 @@ class CollectionSubscriber {
     const { orderBy, valueExtractorForRawRow, offset } = orderByInfo;
     const biggestSentRow = this.biggest;
     const extractedValues = biggestSentRow ? valueExtractorForRawRow(biggestSentRow) : void 0;
-    const minValues = extractedValues !== void 0 ? Array.isArray(extractedValues) ? extractedValues : [extractedValues] : void 0;
+    let minValues;
+    if (extractedValues !== void 0) {
+      minValues = Array.isArray(extractedValues) ? extractedValues : [extractedValues];
+    }
+    const loadRequestKey = this.getLoadRequestKey({
+      minValues,
+      offset,
+      limit: n
+    });
+    if (this.lastLoadRequestKey === loadRequestKey) {
+      return;
+    }
     const normalizedOrderBy = normalizeOrderByPaths(orderBy, this.alias);
     subscription.requestLimitedSnapshot({
       orderBy: normalizedOrderBy,
       limit: n,
       minValues,
-      offset
+      // Omit offset so requestLimitedSnapshot can advance the offset based on
+      // the number of rows already loaded (supports offset-based backends).
+      trackLoadSubsetPromise: false,
+      onLoadSubsetResult: this.orderedLoadSubsetResult
     });
+    this.lastLoadRequestKey = loadRequestKey;
   }
   getWhereClauseForAlias() {
     const sourceWhereClausesCache = this.collectionConfigBuilder.sourceWhereClausesCache;
@@ -11794,18 +11936,45 @@ class CollectionSubscriber {
     }
     return void 0;
   }
-  *trackSentValues(changes, comparator) {
+  trackSentValues(changes, comparator) {
     for (const change of changes) {
-      if (change.type !== `delete`) {
-        if (!this.biggest) {
-          this.biggest = change.value;
-        } else if (comparator(this.biggest, change.value) < 0) {
-          this.biggest = change.value;
-        }
+      if (change.type === `delete`) {
+        continue;
+      }
+      const isNewKey = !this.sentToD2Keys.has(change.key);
+      if (!this.biggest) {
+        this.biggest = change.value;
+        this.lastLoadRequestKey = void 0;
+      } else if (comparator(this.biggest, change.value) < 0) {
+        this.biggest = change.value;
+        this.lastLoadRequestKey = void 0;
+      } else if (isNewKey) {
+        this.lastLoadRequestKey = void 0;
       }
-      yield change;
     }
   }
+  ensureLoadingPromise(subscription) {
+    if (this.subscriptionLoadingPromises.has(subscription)) {
+      return;
+    }
+    let resolve;
+    const promise = new Promise((res) => {
+      resolve = res;
+    });
+    this.subscriptionLoadingPromises.set(subscription, {
+      resolve
+    });
+    this.collectionConfigBuilder.liveQueryCollection._sync.trackLoadPromise(
+      promise
+    );
+  }
+  getLoadRequestKey(options) {
+    return serializeValue({
+      minValues: options.minValues ?? null,
+      offset: options.offset,
+      limit: options.limit
+    });
+  }
 }
 function sendChangesToInput(input, changes, getKey) {
   const multiSetArray = [];
@@ -12333,7 +12502,10 @@ class CollectionConfigBuilder {
     if (this.isInErrorState) {
       return;
     }
-    if (this.currentSyncState?.subscribedToAllCollections && this.allCollectionsReady() && !this.liveQueryCollection?.isLoadingSubset) {
+    const subscribedToAll = this.currentSyncState?.subscribedToAllCollections;
+    const allReady = this.allCollectionsReady();
+    const isLoading = this.liveQueryCollection?.isLoadingSubset;
+    if (subscribedToAll && allReady && !isLoading) {
       markReady();
     }
   }