@rpcbase/client 0.455.0 → 0.456.0

package/dist/{useQuery-BOjtIBwv.js → useQuery-DZqYIJog.js}

@@ -152,6 +152,7 @@ const RtsSsrRuntimeProvider = (t0) => {
 const useRtsSsrRuntime = () => {
   return useContext(RtsSsrRuntimeContext);
 };
+const RTS_QUERY_WINDOW_MAX_COUNT = 4096;
 const memoryStore = /* @__PURE__ */ new Map();
 let reactNativeStorage = null;
 const MMKV_STORAGE_ID = "rpcbase-rts";
@@ -239,6 +240,11 @@ const UNDERSCORE_PREFIX = "$_";
 const DEFAULT_FIND_LIMIT = 4096;
 const INDEXED_DB_ADAPTER = "indexeddb";
 const REACT_NATIVE_SQLITE_ADAPTER = "react-native-sqlite";
+const QUERY_WINDOW_COLLECTION = "$query-windows-v1";
+const QUERY_WINDOW_DOC_TYPE = "rts-query-window";
+const QUERY_WINDOW_SCHEMA_VERSION = 1;
+const QUERY_WINDOW_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+const QUERY_WINDOW_WRITE_ATTEMPTS = 4;
 let storeConfig = null;
 let pouchDbPromise = null;
 let lastAppliedPrefix = null;
@@ -374,8 +380,7 @@ const getPouchDb = async () => {
   }
   return pouchDbPromise;
 };
-const applyPrefix = (PouchDB) => {
-  const prefix = getPrefix();
+const applyPrefix = (PouchDB, prefix = getPrefix()) => {
   if (prefix === lastAppliedPrefix) return;
   PouchDB.prefix = prefix;
   lastAppliedPrefix = prefix;
@@ -386,9 +391,9 @@ const configureRtsPouchStore = (config) => {
   collections.clear();
 };
 const getCollection = async (modelName, options) => {
-  const PouchDB = await getPouchDb();
-  applyPrefix(PouchDB);
   const prefix = getPrefix();
+  const PouchDB = await getPouchDb();
+  applyPrefix(PouchDB, prefix);
   const dbName = `${options.uid}/${modelName}`;
   const dbKey = `${prefix}${dbName}`;
   const existing = collections.get(dbKey);
@@ -401,6 +406,284 @@ const getCollection = async (modelName, options) => {
   collections.set(dbKey, db);
   return db;
 };
+const getQueryWindowScope = (uid) => {
+  if (!storeConfig) {
+    throw new Error("RTS PouchDB store is not configured");
+  }
+  return {
+    appName: storeConfig.appName ?? "",
+    tenantId: storeConfig.tenantId,
+    uid
+  };
+};
+const getQueryWindowFingerprint = (scope, modelName, queryKey) => JSON.stringify([QUERY_WINDOW_SCHEMA_VERSION, scope.appName, scope.tenantId, scope.uid, modelName, queryKey]);
+const getQueryWindowDocumentId = (fingerprint) => `${QUERY_WINDOW_DOC_TYPE}:${encodeURIComponent(fingerprint)}`;
+const getPouchErrorStatus = (error) => {
+  if (!error || typeof error !== "object") return void 0;
+  const status = error.status;
+  return typeof status === "number" && Number.isFinite(status) ? status : void 0;
+};
+const getPouchDocument = async (collection, id) => {
+  try {
+    return await collection.get(id);
+  } catch (error) {
+    if (getPouchErrorStatus(error) === 404) return null;
+    throw error;
+  }
+};
+const normalizeQueryWindowPageInfo = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.hasNextPage !== "boolean" || typeof raw.hasPrevPage !== "boolean") return null;
+  if (raw.nextCursor !== void 0 && typeof raw.nextCursor !== "string") return null;
+  if (raw.prevCursor !== void 0 && typeof raw.prevCursor !== "string") return null;
+  const nextCursor = typeof raw.nextCursor === "string" && raw.nextCursor ? raw.nextCursor : void 0;
+  const prevCursor = typeof raw.prevCursor === "string" && raw.prevCursor ? raw.prevCursor : void 0;
+  return {
+    hasNextPage: raw.hasNextPage,
+    hasPrevPage: raw.hasPrevPage,
+    ...nextCursor ? {
+      nextCursor
+    } : {},
+    ...prevCursor ? {
+      prevCursor
+    } : {}
+  };
+};
+const isValidQueryWindowServerVersion = (value) => {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+};
+const isQueryWindowData = (value) => Array.isArray(value) && value.every((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+const parseQueryWindowSnapshot = (doc, expected) => {
+  if (doc.type !== QUERY_WINDOW_DOC_TYPE || doc.schemaVersion !== QUERY_WINDOW_SCHEMA_VERSION) return null;
+  if (doc.fingerprint !== expected.fingerprint) return null;
+  if (doc.modelName !== expected.modelName || doc.queryKey !== expected.queryKey) return null;
+  const scope = doc.scope;
+  if (!scope || typeof scope !== "object" || Array.isArray(scope)) return null;
+  const rawScope = scope;
+  if (rawScope.appName !== expected.scope.appName || rawScope.tenantId !== expected.scope.tenantId || rawScope.uid !== expected.scope.uid) {
+    return null;
+  }
+  if (!isQueryWindowData(doc.data)) return null;
+  const pageInfo = normalizeQueryWindowPageInfo(doc.pageInfo);
+  if (!pageInfo) return null;
+  const requestedCount = doc.requestedCount;
+  if (!Number.isSafeInteger(requestedCount) || requestedCount <= 0 || requestedCount > RTS_QUERY_WINDOW_MAX_COUNT || doc.data.length > requestedCount) {
+    return null;
+  }
+  const storedAt = doc.storedAt;
+  if (typeof storedAt !== "number" || !Number.isFinite(storedAt) || storedAt < 0) return null;
+  const totalCount = doc.totalCount;
+  if (totalCount !== void 0 && (!Number.isSafeInteger(totalCount) || totalCount < 0)) {
+    return null;
+  }
+  const serverVersion = doc.serverVersion;
+  if (serverVersion !== void 0 && !isValidQueryWindowServerVersion(serverVersion)) return null;
+  const serverEpoch = doc.serverEpoch;
+  if (serverEpoch !== void 0 && (typeof serverEpoch !== "string" || !serverEpoch)) return null;
+  if (serverEpoch === void 0 !== (serverVersion === void 0)) return null;
+  return {
+    data: doc.data,
+    pageInfo,
+    ...typeof totalCount === "number" ? {
+      totalCount
+    } : {},
+    requestedCount,
+    ...serverEpoch !== void 0 ? {
+      serverEpoch
+    } : {},
+    ...serverVersion !== void 0 ? {
+      serverVersion
+    } : {},
+    storedAt
+  };
+};
+const deleteQueryWindowDocument = async (collection, doc) => {
+  const id = typeof doc._id === "string" ? doc._id : "";
+  const rev = typeof doc._rev === "string" ? doc._rev : "";
+  if (!id || !rev) return;
+  await collection.put({
+    _id: id,
+    _rev: rev,
+    _deleted: true
+  }).catch(() => void 0);
+};
+const readQueryWindowSnapshot = async ({
+  modelName,
+  queryKey,
+  uid,
+  now = Date.now()
+}) => {
+  const scope = getQueryWindowScope(uid);
+  const fingerprint = getQueryWindowFingerprint(scope, modelName, queryKey);
+  const id = getQueryWindowDocumentId(fingerprint);
+  const collection = await getCollection(QUERY_WINDOW_COLLECTION, {
+    uid
+  });
+  const doc = await getPouchDocument(collection, id);
+  if (!doc) return {
+    hit: false
+  };
+  const snapshot = parseQueryWindowSnapshot(doc, {
+    fingerprint,
+    scope,
+    modelName,
+    queryKey
+  });
+  if (!snapshot || now - snapshot.storedAt >= QUERY_WINDOW_TTL_MS) {
+    await deleteQueryWindowDocument(collection, doc);
+    return {
+      hit: false
+    };
+  }
+  return {
+    hit: true,
+    snapshot
+  };
+};
+const writeQueryWindowSnapshot = async ({
+  modelName,
+  queryKey,
+  uid,
+  data,
+  pageInfo: rawPageInfo,
+  totalCount,
+  requestedCount,
+  serverEpoch,
+  serverVersion,
+  storedAt: rawStoredAt
+}) => {
+  if (!modelName.trim()) throw new Error("writeQueryWindowSnapshot: modelName must be a non-empty string");
+  if (!queryKey) throw new Error("writeQueryWindowSnapshot: queryKey must be a non-empty string");
+  if (!uid.trim()) throw new Error("writeQueryWindowSnapshot: uid must be a non-empty string");
+  if (!isQueryWindowData(data)) throw new Error("writeQueryWindowSnapshot: data must contain objects");
+  const pageInfo = normalizeQueryWindowPageInfo(rawPageInfo);
+  if (!pageInfo) throw new Error("writeQueryWindowSnapshot: invalid pageInfo");
+  if (!Number.isSafeInteger(requestedCount) || requestedCount <= 0 || requestedCount > RTS_QUERY_WINDOW_MAX_COUNT || data.length > requestedCount) {
+    throw new Error("writeQueryWindowSnapshot: requestedCount must cover data and be between 1 and 4096");
+  }
+  if (totalCount !== void 0 && (!Number.isSafeInteger(totalCount) || totalCount < 0)) {
+    throw new Error("writeQueryWindowSnapshot: totalCount must be a non-negative integer");
+  }
+  if (serverVersion !== void 0 && !isValidQueryWindowServerVersion(serverVersion)) {
+    throw new Error("writeQueryWindowSnapshot: invalid serverVersion");
+  }
+  if (serverEpoch !== void 0 && (typeof serverEpoch !== "string" || !serverEpoch)) {
+    throw new Error("writeQueryWindowSnapshot: invalid serverEpoch");
+  }
+  if (serverEpoch === void 0 !== (serverVersion === void 0)) {
+    throw new Error("writeQueryWindowSnapshot: serverEpoch and serverVersion must be provided together");
+  }
+  const storedAt = rawStoredAt ?? Date.now();
+  if (!Number.isFinite(storedAt) || storedAt < 0) {
+    throw new Error("writeQueryWindowSnapshot: storedAt must be a non-negative finite number");
+  }
+  const scope = getQueryWindowScope(uid);
+  const fingerprint = getQueryWindowFingerprint(scope, modelName, queryKey);
+  const id = getQueryWindowDocumentId(fingerprint);
+  const collection = await getCollection(QUERY_WINDOW_COLLECTION, {
+    uid
+  });
+  const snapshot = {
+    data,
+    pageInfo,
+    ...totalCount !== void 0 ? {
+      totalCount
+    } : {},
+    requestedCount,
+    ...serverEpoch !== void 0 ? {
+      serverEpoch
+    } : {},
+    ...serverVersion !== void 0 ? {
+      serverVersion
+    } : {},
+    storedAt
+  };
+  let lastConflict;
+  for (let attempt = 0; attempt < QUERY_WINDOW_WRITE_ATTEMPTS; attempt += 1) {
+    const current = await getPouchDocument(collection, id);
+    const currentSnapshot = current ? parseQueryWindowSnapshot(current, {
+      fingerprint,
+      scope,
+      modelName,
+      queryKey
+    }) : null;
+    if (currentSnapshot && (currentSnapshot.serverEpoch === serverEpoch && currentSnapshot.serverVersion !== void 0 && serverVersion !== void 0 && currentSnapshot.serverVersion >= serverVersion || (!serverEpoch || currentSnapshot.serverEpoch !== serverEpoch) && currentSnapshot.storedAt > storedAt)) {
+      return currentSnapshot;
+    }
+    const rev = typeof current?._rev === "string" ? current._rev : void 0;
+    const doc = {
+      _id: id,
+      ...rev ? {
+        _rev: rev
+      } : {},
+      type: QUERY_WINDOW_DOC_TYPE,
+      schemaVersion: QUERY_WINDOW_SCHEMA_VERSION,
+      fingerprint,
+      scope,
+      modelName,
+      queryKey,
+      data,
+      pageInfo,
+      ...totalCount !== void 0 ? {
+        totalCount
+      } : {},
+      requestedCount,
+      ...serverEpoch !== void 0 ? {
+        serverEpoch
+      } : {},
+      ...serverVersion !== void 0 ? {
+        serverVersion
+      } : {},
+      storedAt
+    };
+    try {
+      await collection.put(doc);
+      return snapshot;
+    } catch (error) {
+      if (getPouchErrorStatus(error) !== 409) throw error;
+      lastConflict = error;
+    }
+  }
+  throw lastConflict ?? new Error("writeQueryWindowSnapshot: failed to persist snapshot");
+};
+const invalidateQueryWindowSnapshots = async ({
+  uid,
+  modelName
+}) => {
+  const collection = await getCollection(QUERY_WINDOW_COLLECTION, {
+    uid
+  });
+  const selector = {
+    type: QUERY_WINDOW_DOC_TYPE,
+    ...modelName ? {
+      modelName
+    } : {}
+  };
+  for (let batch = 0; batch < 32; batch += 1) {
+    const {
+      docs
+    } = await collection.find({
+      selector,
+      fields: ["_id", "_rev"],
+      limit: DEFAULT_FIND_LIMIT
+    });
+    const deletions = docs.map((doc) => ({
+      _id: typeof doc._id === "string" ? doc._id : "",
+      _rev: typeof doc._rev === "string" ? doc._rev : "",
+      _deleted: true
+    })).filter((doc) => doc._id && doc._rev);
+    if (!deletions.length) return;
+    const results = await collection.bulkDocs(deletions);
+    const hasConflict = Array.isArray(results) && results.some((result) => {
+      if (!result || typeof result !== "object") return false;
+      const record = result;
+      return record.error === true || record.status === 409;
+    });
+    if (hasConflict) continue;
+    if (docs.length < DEFAULT_FIND_LIMIT) return;
+  }
+};
 const replaceQueryKeys = (value, replaceKey) => {
   if (typeof value !== "object" || value === null) {
     return value;
@@ -1288,13 +1571,16 @@ const serializeRtsQueryValue = (value) => {
   }) ?? "";
 };
 const computeRtsQueryKey = (query, options) => {
-  const key = options.key ?? "";
-  const projection = options.projection ? serializeRtsQueryValue(options.projection) : "";
-  const sort = options.sort ? serializeRtsQueryValue(options.sort) : "";
-  const limit = typeof options.limit === "number" ? String(options.limit) : "";
-  const populate = options.populate ? serializeRtsQueryValue(options.populate) : "";
-  const pagination = options.pagination ? serializeRtsQueryValue(options.pagination) : "";
-  return `${key}${serializeRtsQueryValue(query)}${projection}${sort}${limit}${populate}${pagination}`;
+  return serializeRtsQueryValue({
+    version: 2,
+    key: options.key ?? null,
+    query,
+    projection: options.projection ?? null,
+    sort: options.sort ?? null,
+    limit: typeof options.limit === "number" ? options.limit : null,
+    populate: options.populate ?? null,
+    pagination: options.pagination ?? null
+  });
 };
 const hasSnapshotError = (snapshot) => {
   return snapshot?.error !== null && snapshot?.error !== void 0;
@@ -1306,11 +1592,15 @@ const SERVER_RECONNECT_DELAY_MAX_MS = 15e3;
 const RUN_NETWORK_QUERY_TIMEOUT_ERROR = "runNetworkQuery: request timed out";
 const RUN_NETWORK_COUNT_TIMEOUT_ERROR = "runNetworkCount: request timed out";
 let socket = null;
+let socketReadyForMessages = false;
 let connectPromise = null;
+let pendingConnectionAttempt = null;
 let explicitDisconnect = false;
 let currentTenantId = null;
 let currentUid = null;
 let connectOptions = {};
+let connectionGeneration = 0;
+let connectionEpoch = null;
 const localTxnBuf = [];
 const queryCallbacks = /* @__PURE__ */ new Map();
 const countCallbacks = /* @__PURE__ */ new Map();
@@ -1318,9 +1608,11 @@ const subscriptions = /* @__PURE__ */ new Map();
 const countSubscriptions = /* @__PURE__ */ new Map();
 const messageCallbacks = /* @__PURE__ */ new Map();
 const rtsMessageCallbacks = /* @__PURE__ */ new Map();
+const pendingWindowRequests = /* @__PURE__ */ new Map();
 let reconnectTimer = null;
 let reconnectAttempts = 0;
 let hasEstablishedConnection = false;
+let forceInitialQueryOnNextConnection = false;
 let pendingServerReconnectJitter = false;
 let syncPromise = null;
 let syncKey = null;
@@ -1422,10 +1714,33 @@ const buildSocketUrl = (_tenantId, _uid, options) => {
   return base.toString();
 };
 const sendToServer = (message) => {
-  if (!socket) return;
+  if (!socket || !socketReadyForMessages) return;
   if (socket.readyState !== WebSocket.OPEN) return;
   socket.send(JSON.stringify(message));
 };
+const isSocketReady = () => Boolean(socket && socketReadyForMessages && socket.readyState === WebSocket.OPEN);
+const normalizeRequestedCount = (value) => {
+  if (!Number.isSafeInteger(value)) return void 0;
+  if (value < 1 || value > RTS_QUERY_WINDOW_MAX_COUNT) return void 0;
+  return value;
+};
+const getSubscriptionServerOptions = (subscription) => {
+  if (!subscription.options.pagination || !subscription.requestedCount) {
+    return subscription.options;
+  }
+  const {
+    cursor: _cursor,
+    direction: _direction,
+    ...pagination
+  } = subscription.options.pagination;
+  return {
+    ...subscription.options,
+    pagination: {
+      ...pagination,
+      limit: subscription.requestedCount
+    }
+  };
+};
 const resubscribeAll = ({
   forceInitialQuery
 }) => {
@@ -1436,7 +1751,7 @@ const resubscribeAll = ({
       modelName: sub.modelName,
       queryKey: sub.queryKey,
       query: sub.query,
-      options: sub.options,
+      options: getSubscriptionServerOptions(sub),
       runInitialQuery
     });
   }
@@ -1457,6 +1772,12 @@ const clearReconnectTimer = () => {
   clearRuntimeTimeout(reconnectTimer);
   reconnectTimer = null;
 };
+const rejectPendingConnectionAttempt = () => {
+  const attempt = pendingConnectionAttempt;
+  if (!attempt) return;
+  pendingConnectionAttempt = null;
+  attempt.reject(new Error("RTS WebSocket connection attempt superseded"));
+};
 const scheduleReconnect = () => {
   clearReconnectTimer();
   if (explicitDisconnect) {
@@ -1509,9 +1830,68 @@ const normalizeTotalCount$1 = (value) => {
   if (!Number.isFinite(value) || value < 0) return void 0;
   return Math.floor(value);
 };
+const normalizeQueryWindow = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const raw = value;
+  const requestedCount = normalizeRequestedCount(raw.requestedCount);
+  if (!requestedCount) return void 0;
+  const version = Number.isSafeInteger(raw.version) && raw.version >= 0 ? raw.version : void 0;
+  return {
+    requestedCount,
+    ...version !== void 0 ? {
+      version
+    } : {}
+  };
+};
+const settlePendingWindowRequests = (cbKey, requestedCount, success) => {
+  const pending = pendingWindowRequests.get(cbKey);
+  if (!pending?.size) return;
+  for (const request of Array.from(pending)) {
+    if (request.requestedCount !== requestedCount) continue;
+    clearRuntimeTimeout(request.timeoutId);
+    pending.delete(request);
+    if (!success) {
+      const subscription = subscriptions.get(cbKey);
+      if (subscription?.requestedCount === request.requestedCount) {
+        const snapshotRequestedCount = subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot) ? subscription.lastSnapshot.context.window?.requestedCount : void 0;
+        const rollbackRequestedCount = snapshotRequestedCount ?? request.previousRequestedCount;
+        subscription.windowIntentVersion += 1;
+        subscription.requestedCount = rollbackRequestedCount;
+        sendToServer({
+          type: "set-query-window",
+          modelName: subscription.modelName,
+          queryKey: subscription.queryKey,
+          requestedCount: rollbackRequestedCount
+        });
+      }
+    }
+    request.resolve(success);
+  }
+  if (!pending.size) pendingWindowRequests.delete(cbKey);
+};
+const failPendingWindowRequests = (cbKey) => {
+  const pending = pendingWindowRequests.get(cbKey);
+  if (!pending?.size) return;
+  for (const request of Array.from(pending)) {
+    settlePendingWindowRequests(cbKey, request.requestedCount, false);
+  }
+};
+const cancelPendingWindowRequests = (cbKey) => {
+  const entries = cbKey ? [[cbKey, pendingWindowRequests.get(cbKey)]] : Array.from(pendingWindowRequests.entries());
+  for (const [key, pending] of entries) {
+    if (!pending) continue;
+    for (const request of pending) {
+      clearRuntimeTimeout(request.timeoutId);
+      request.resolve(false);
+    }
+    pendingWindowRequests.delete(key);
+  }
+};
 const updateQuerySubscriptionSnapshot = (subscription, snapshot) => {
   if (snapshot.context.source === "cache" && subscription.lastSnapshot?.context.source === "network") {
-    return false;
+    const cachedCount = snapshot.context.window?.requestedCount;
+    const networkCount = subscription.lastSnapshot.context.window?.requestedCount;
+    if (!cachedCount || !networkCount || cachedCount <= networkCount) return false;
   }
   subscription.lastSnapshot = snapshot;
   return true;
@@ -1548,12 +1928,21 @@ const dispatchCountSnapshotToOneshotCallbacks = (cbKey, snapshot) => {
   }
 };
 const requestRegisteredQueryRefresh = (subscription) => {
+  if (subscription.options.pagination && subscription.requestedCount) {
+    sendToServer({
+      type: "set-query-window",
+      modelName: subscription.modelName,
+      queryKey: subscription.queryKey,
+      requestedCount: subscription.requestedCount
+    });
+    return;
+  }
   sendToServer({
     type: "run-query",
     modelName: subscription.modelName,
     queryKey: subscription.queryKey,
     query: subscription.query,
-    options: subscription.options
+    options: getSubscriptionServerOptions(subscription)
   });
 };
 const requestRegisteredCountRefresh = (subscription) => {
@@ -1566,7 +1955,61 @@ const requestRegisteredCountRefresh = (subscription) => {
   });
 };
 const requestSubscriptionLocalQuery = (cbKey, subscription) => {
-  if (!currentUid || subscription.options.pagination) return;
+  if (!currentUid) return false;
+  const uid = currentUid;
+  const generation = connectionGeneration;
+  if (subscription.options.pagination) {
+    const requestedCountAtStart = subscription.requestedCount;
+    const windowIntentVersionAtStart = subscription.windowIntentVersion;
+    const localQueryPromise = readQueryWindowSnapshot({
+      uid,
+      modelName: subscription.modelName,
+      queryKey: subscription.queryKey
+    }).then((result) => {
+      if (!result.hit || generation !== connectionGeneration) return;
+      const currentSubscription = subscriptions.get(cbKey);
+      if (!currentSubscription) return;
+      const requestedCount = normalizeRequestedCount(result.snapshot.requestedCount);
+      if (!requestedCount) return;
+      if (currentSubscription.windowIntentVersion !== windowIntentVersionAtStart) return;
+      if (currentSubscription.requestedCount !== requestedCountAtStart) return;
+      const snapshot = {
+        error: null,
+        data: result.snapshot.data,
+        context: {
+          source: "cache",
+          pageInfo: result.snapshot.pageInfo,
+          ...result.snapshot.totalCount !== void 0 ? {
+            totalCount: result.snapshot.totalCount
+          } : {},
+          window: {
+            requestedCount
+          }
+        }
+      };
+      if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
+      currentSubscription.requestedCount = requestedCount;
+      currentSubscription.windowIntentVersion += 1;
+      if (requestedCount !== requestedCountAtStart) {
+        sendToServer({
+          type: "set-query-window",
+          modelName: currentSubscription.modelName,
+          queryKey: currentSubscription.queryKey,
+          requestedCount
+        });
+      }
+      dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
+    }).catch(() => {
+    });
+    subscription.localQueryPromise = localQueryPromise;
+    void localQueryPromise.finally(() => {
+      const currentSubscription = subscriptions.get(cbKey);
+      if (currentSubscription?.localQueryPromise === localQueryPromise) {
+        delete currentSubscription.localQueryPromise;
+      }
+    });
+    return true;
+  }
   const populateCache = subscription.populateCache;
   const hasPopulate = Boolean(populateCache);
   if (hasPopulate && populateCache) {
@@ -1574,7 +2017,7 @@ const requestSubscriptionLocalQuery = (cbKey, subscription) => {
       modelName: subscription.modelName,
       query: subscription.query,
       options: {
-        uid: currentUid,
+        uid,
         projection: populateCache.rootProjection,
         sort: subscription.options.sort,
         limit: subscription.options.limit,
@@ -1586,6 +2029,7 @@ const requestSubscriptionLocalQuery = (cbKey, subscription) => {
       context
     }) => {
       if (!hit) return;
+      if (generation !== connectionGeneration) return;
       const currentSubscription = subscriptions.get(cbKey);
       if (!currentSubscription) return;
       const snapshot = {
@@ -1597,13 +2041,13 @@ const requestSubscriptionLocalQuery = (cbKey, subscription) => {
       dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
     }).catch(() => {
     });
-    return;
+    return true;
   }
   void runQuery({
     modelName: subscription.modelName,
     query: subscription.query,
     options: {
-      uid: currentUid,
+      uid,
       projection: subscription.options.projection,
       sort: subscription.options.sort,
       limit: subscription.options.limit
@@ -1612,6 +2056,7 @@ const requestSubscriptionLocalQuery = (cbKey, subscription) => {
     data,
     context
   }) => {
+    if (generation !== connectionGeneration) return;
     const currentSubscription = subscriptions.get(cbKey);
     if (!currentSubscription) return;
     const snapshot = {
@@ -1623,6 +2068,7 @@ const requestSubscriptionLocalQuery = (cbKey, subscription) => {
     dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
   }).catch(() => {
   });
+  return true;
 };
 const handleQueryPayload = (payload) => {
   const {
@@ -1639,9 +2085,17 @@ const handleQueryPayload = (payload) => {
   if (!hasSubscriptionCallbacks && !hasOneshotCallbacks) return;
   const pageInfo = normalizePageInfo$1(payload.pageInfo);
   const totalCount = normalizeTotalCount$1(payload.totalCount);
+  const queryWindow = normalizeQueryWindow(payload.window);
   const populateCache = subscription?.populateCache;
   const hasPopulate = Boolean(populateCache);
   const hasPagination = Boolean(subscription?.options?.pagination || pageInfo || totalCount !== void 0);
+  if (subscription?.options.pagination && queryWindow) {
+    if (queryWindow.requestedCount !== subscription.requestedCount) return;
+    if (queryWindow.version !== void 0 && queryWindow.version <= subscription.lastNetworkVersion) return;
+    if (queryWindow.version !== void 0) {
+      subscription.lastNetworkVersion = queryWindow.version;
+    }
+  }
   const isLocal = !!(txnId && localTxnBuf.includes(txnId));
   const context = {
     source: "network",
@@ -1652,6 +2106,9 @@ const handleQueryPayload = (payload) => {
     } : {},
     ...totalCount !== void 0 ? {
       totalCount
+    } : {},
+    ...queryWindow ? {
+      window: queryWindow
     } : {}
   };
   const snapshot = {
@@ -1664,13 +2121,50 @@ const handleQueryPayload = (payload) => {
       dispatchQuerySnapshotToSubscription(subscription, snapshot);
     }
     dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
+    if (queryWindow) {
+      settlePendingWindowRequests(cbKey, queryWindow.requestedCount, false);
+    } else if (subscription?.options.pagination) {
+      failPendingWindowRequests(cbKey);
+    }
     return;
   }
   if (subscription && updateQuerySubscriptionSnapshot(subscription, snapshot)) {
     dispatchQuerySnapshotToSubscription(subscription, snapshot);
   }
   dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
+  if (queryWindow) {
+    settlePendingWindowRequests(cbKey, queryWindow.requestedCount, true);
+  }
   if (!currentUid) return;
+  if (subscription?.options.pagination && queryWindow && pageInfo && Array.isArray(data) && connectionEpoch) {
+    const uid = currentUid;
+    const generation = connectionGeneration;
+    const serverEpoch = connectionEpoch;
+    const localQueryPromise = subscription.localQueryPromise;
+    void Promise.resolve().then(async () => {
+      await localQueryPromise;
+      if (generation !== connectionGeneration || serverEpoch !== connectionEpoch) return;
+      const currentSubscription = subscriptions.get(cbKey);
+      if (!currentSubscription || currentSubscription.requestedCount !== queryWindow.requestedCount) return;
+      await writeQueryWindowSnapshot({
+        uid,
+        modelName,
+        queryKey,
+        data,
+        pageInfo,
+        ...totalCount !== void 0 ? {
+          totalCount
+        } : {},
+        requestedCount: queryWindow.requestedCount,
+        ...queryWindow.version !== void 0 ? {
+          serverEpoch,
+          serverVersion: queryWindow.version
+        } : {}
+      });
+    }).catch(() => {
+    });
+    return;
+  }
   const docs = Array.isArray(data) ? data.filter(isDocWithId) : [];
   if (hasPagination) return;
   if (!docs.length) return;
@@ -1789,7 +2283,7 @@ const writeStoredSeq = (key, value) => {
     return;
   }
 };
-const applyChangeBatch = async (changes, uid) => {
+const applyChangeBatch = async (changes, uid, isCurrent) => {
   const resetModels = /* @__PURE__ */ new Set();
   const deletesByModel = /* @__PURE__ */ new Map();
   for (const change of changes) {
@@ -1808,24 +2302,35 @@ const applyChangeBatch = async (changes, uid) => {
     }
   }
   for (const modelName of resetModels) {
+    if (!isCurrent()) return false;
     await destroyCollection(modelName, uid).catch(() => {
     });
   }
   for (const [modelName, ids] of deletesByModel.entries()) {
     if (resetModels.has(modelName)) continue;
+    if (!isCurrent()) return false;
     await deleteDocs(modelName, ids, uid).catch(() => {
     });
   }
+  if (resetModels.size || deletesByModel.size) {
+    if (!isCurrent()) return false;
+    await invalidateQueryWindowSnapshots({
+      uid
+    }).catch(() => {
+    });
+  }
+  return true;
 };
-const syncRtsChanges = async (tenantId, uid, options = {}) => {
+const syncRtsChangesWithResult = async (tenantId, uid, options = {}, isCurrent = () => true) => {
   ensureSyncRuntime();
-  if (!tenantId || !uid) return;
+  if (!tenantId || !uid) return false;
   const storageKey = getSyncStorageKey({
     tenantId,
     uid,
     appName: options.appName
   });
   let sinceSeq = readStoredSeq(storageKey);
+  let cacheInvalidated = false;
   const syncUrl = buildSyncChangesUrl(tenantId, {
     url: options.url
   });
@@ -1841,21 +2346,23 @@ const syncRtsChanges = async (tenantId, uid, options = {}) => {
         limit: 2e3
       })
     });
-    if (!response.ok) return;
+    if (!isCurrent()) return false;
+    if (!response.ok) return cacheInvalidated;
     const payload = await response.json().catch(() => null);
-    if (!payload || typeof payload !== "object") return;
+    if (!payload || typeof payload !== "object") return cacheInvalidated;
     const payloadObj = payload;
     const ok = payloadObj.ok;
-    if (ok !== true) return;
+    if (ok !== true) return cacheInvalidated;
     const latestSeq = Number(payloadObj.latestSeq ?? 0);
     const needsFullResync = Boolean(payloadObj.needsFullResync);
     if (needsFullResync) {
+      if (!isCurrent()) return false;
       resetRtsPouchStore({
         tenantId,
         appName: options.appName
       });
       writeStoredSeq(storageKey, latestSeq);
-      return;
+      return true;
     }
     const changesRaw = payloadObj.changes;
     const changes = Array.isArray(changesRaw) ? changesRaw : [];
@@ -1877,31 +2384,37 @@ const syncRtsChanges = async (tenantId, uid, options = {}) => {
     }).filter((c2) => c2 !== null).filter((c2) => Number.isFinite(c2.seq) && c2.seq > 0 && c2.modelName && (c2.op === "reset_model" || !!c2.docId));
     if (!normalized.length) {
       writeStoredSeq(storageKey, latestSeq);
-      return;
+      return cacheInvalidated;
     }
-    await applyChangeBatch(normalized, uid);
+    const applied = await applyChangeBatch(normalized, uid, isCurrent);
+    if (!applied) return false;
+    cacheInvalidated = true;
     const lastSeq = normalized.reduce((max, c2) => c2.seq > max ? c2.seq : max, sinceSeq);
     sinceSeq = lastSeq;
     writeStoredSeq(storageKey, sinceSeq);
     if (latestSeq > 0 && sinceSeq >= latestSeq) {
-      return;
+      return cacheInvalidated;
     }
   }
+  return cacheInvalidated;
+};
+const syncRtsChanges = async (tenantId, uid, options = {}) => {
+  await syncRtsChangesWithResult(tenantId, uid, options);
 };
 const ensureSynced = (tenantId, uid, options) => {
-  if (options.syncChanges === false) return;
+  if (options.syncChanges === false) return Promise.resolve(false);
   const key = `${options.appName ?? ""}:${tenantId}:${uid}`;
-  if (syncPromise && syncKey === key) return;
+  if (syncPromise && syncKey === key) return syncPromise;
   syncKey = key;
-  syncPromise = syncRtsChanges(tenantId, uid, {
+  syncPromise = syncRtsChangesWithResult(tenantId, uid, {
     appName: options.appName,
     url: options.url
-  }).catch(() => {
-  }).finally(() => {
+  }, () => currentTenantId === tenantId && currentUid === uid && (connectOptions.appName ?? "") === (options.appName ?? "")).catch(() => false).finally(() => {
     if (syncKey === key) {
       syncPromise = null;
     }
   });
+  return syncPromise;
 };
 const connectInternal = (tenantId, uid, options, {
   resetReconnectAttempts
@@ -1918,37 +2431,84 @@ const connectInternal = (tenantId, uid, options, {
       appName: options.appName
     });
   }
-  ensureSynced(tenantId, uid, options);
   if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) {
     return connectPromise ?? Promise.resolve();
   }
+  const synchronization = ensureSynced(tenantId, uid, options);
   explicitDisconnect = false;
   clearReconnectTimer();
+  socketReadyForMessages = false;
   const url = buildSocketUrl(tenantId, uid, options);
   connectPromise = new Promise((resolve, reject) => {
     if (resetReconnectAttempts) reconnectAttempts = 0;
     let opened = false;
     let settled = false;
+    let subscriptionsStarted = false;
+    let cacheInvalidatedBeforeSubscriptions = false;
+    const generation = ++connectionGeneration;
+    const epoch = `${Date.now().toString(36)}.${generation.toString(36)}.${Math.random().toString(36).slice(2, 10)}`;
+    connectionEpoch = epoch;
+    pendingConnectionAttempt = {
+      generation,
+      reject: (error) => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      }
+    };
     setConnectionStatus("connecting");
-    socket = new WebSocket(url);
-    socket.addEventListener("open", () => {
+    const nextSocket = new WebSocket(url);
+    socket = nextSocket;
+    if (options.syncChanges !== false) {
+      void synchronization.then((cacheInvalidated) => {
+        if (!cacheInvalidated || generation !== connectionGeneration) return;
+        if (!subscriptionsStarted) {
+          cacheInvalidatedBeforeSubscriptions = true;
+          return;
+        }
+        if (nextSocket.readyState !== WebSocket.OPEN) return;
+        for (const subscription of subscriptions.values()) {
+          if (!subscription.options.pagination) continue;
+          requestRegisteredQueryRefresh(subscription);
+        }
+      });
+    }
+    nextSocket.addEventListener("open", () => {
+      if (generation !== connectionGeneration) return;
       opened = true;
       settled = true;
+      if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
       reconnectAttempts = 0;
       pendingServerReconnectJitter = false;
+      socketReadyForMessages = true;
       setConnectionStatus("connected");
-      const forceInitialQuery = hasEstablishedConnection;
+      for (const subscription of subscriptions.values()) {
+        subscription.lastNetworkVersion = 0;
+        if (subscription.runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery) {
+          const cbKey = `${subscription.modelName}.${subscription.queryKey}`;
+          subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
+        }
+      }
+      const forceInitialQuery = hasEstablishedConnection || forceInitialQueryOnNextConnection || cacheInvalidatedBeforeSubscriptions;
       resubscribeAll({
         forceInitialQuery
       });
+      forceInitialQueryOnNextConnection = false;
+      subscriptionsStarted = true;
       hasEstablishedConnection = true;
       resolve();
     });
-    socket.addEventListener("message", handleMessage);
-    socket.addEventListener("close", (event) => {
-      if (!opened && !settled) {
+    nextSocket.addEventListener("message", (event) => {
+      if (generation !== connectionGeneration) return;
+      handleMessage(event);
+    });
+    nextSocket.addEventListener("close", (event) => {
+      if (generation !== connectionGeneration) return;
+      socketReadyForMessages = false;
+      if (!settled) {
         settled = true;
-        const error = new Error(`RTS WebSocket closed before opening (code=${event.code})`);
+        if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
+        const error = new Error(`RTS WebSocket closed before becoming ready (code=${event.code})`);
         setConnectionStatus("error", error);
         reject(error);
       }
@@ -1962,9 +2522,12 @@ const connectInternal = (tenantId, uid, options, {
       connectPromise = null;
       scheduleReconnect();
     });
-    socket.addEventListener("error", (err) => {
+    nextSocket.addEventListener("error", (err) => {
+      if (generation !== connectionGeneration) return;
       if (settled) return;
       settled = true;
+      if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
+      socketReadyForMessages = false;
       const error = err instanceof Error ? err : new Error("RTS WebSocket error");
       setConnectionStatus("error", error);
       reject(error);
@@ -1973,14 +2536,19 @@ const connectInternal = (tenantId, uid, options, {
   return connectPromise;
 };
 const connect = (tenantId, uid, options = {}) => {
+  const identityChanged = currentTenantId !== null && (currentTenantId !== tenantId || currentUid !== uid || (connectOptions.appName ?? "") !== (options.appName ?? ""));
+  if (identityChanged) return reconnect(tenantId, uid, options);
   return connectInternal(tenantId, uid, options, {
     resetReconnectAttempts: true
   });
 };
 const disconnect = () => {
   explicitDisconnect = true;
+  connectionGeneration += 1;
+  rejectPendingConnectionAttempt();
   clearReconnectTimer();
   hasEstablishedConnection = false;
+  forceInitialQueryOnNextConnection = false;
   pendingServerReconnectJitter = false;
   if (socket) {
     try {
@@ -1989,11 +2557,54 @@ const disconnect = () => {
     }
   }
   socket = null;
+  socketReadyForMessages = false;
   connectPromise = null;
+  connectionEpoch = null;
+  cancelPendingWindowRequests();
   setConnectionStatus("idle");
 };
 const reconnect = (tenantId, uid, options = {}) => {
+  const hasPreviousIdentity = currentTenantId !== null && currentUid !== null;
+  const identityChanged = hasPreviousIdentity && (currentTenantId !== tenantId || currentUid !== uid || (connectOptions.appName ?? "") !== (options.appName ?? ""));
+  if (identityChanged) {
+    cancelPendingWindowRequests();
+    for (const subscription of subscriptions.values()) {
+      subscription.hasRequestedInitialLocalQuery = false;
+      subscription.lastSnapshot = void 0;
+      subscription.lastNetworkVersion = 0;
+      subscription.windowIntentVersion += 1;
+      subscription.requestedCount = subscription.initialWindowSize;
+      delete subscription.localQueryPromise;
+      dispatchQuerySnapshotToSubscription(subscription, {
+        error: null,
+        data: void 0,
+        context: {
+          source: "cache",
+          reset: true,
+          ...subscription.initialWindowSize ? {
+            window: {
+              requestedCount: subscription.initialWindowSize
+            }
+          } : {}
+        }
+      });
+    }
+    for (const subscription of countSubscriptions.values()) {
+      subscription.lastSnapshot = void 0;
+      dispatchCountSnapshotToSubscription(subscription, {
+        error: null,
+        count: void 0,
+        context: {
+          source: "cache",
+          reset: true
+        }
+      });
+    }
+  }
+  forceInitialQueryOnNextConnection = hasEstablishedConnection || identityChanged;
   explicitDisconnect = true;
+  connectionGeneration += 1;
+  rejectPendingConnectionAttempt();
   clearReconnectTimer();
   pendingServerReconnectJitter = false;
   if (socket) {
@@ -2003,8 +2614,12 @@ const reconnect = (tenantId, uid, options = {}) => {
     }
   }
   socket = null;
+  socketReadyForMessages = false;
   connectPromise = null;
-  return connect(tenantId, uid, options);
+  connectionEpoch = null;
+  return connectInternal(tenantId, uid, options, {
+    resetReconnectAttempts: true
+  });
 };
 const getConnectionStatus = () => {
   return connectionStatus;
@@ -2041,7 +2656,7 @@ const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behav
     projection: options.projection,
     populate: options.populate
   }, "registerQuery");
-  const hasPagination = Boolean(options.pagination);
+  const initialWindowSize = options.pagination ? normalizeRequestedCount(options.pagination.limit) : void 0;
   const existingSubscription = subscriptions.get(cbKey);
   const subscription = existingSubscription ?? {
     modelName,
@@ -2050,7 +2665,14 @@ const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behav
     queryKey,
     callbacks: /* @__PURE__ */ new Set(),
     runInitialNetworkQuery,
+    runInitialLocalQuery,
     hasRequestedInitialLocalQuery: false,
+    lastNetworkVersion: 0,
+    windowIntentVersion: 0,
+    ...initialWindowSize ? {
+      initialWindowSize,
+      requestedCount: initialWindowSize
+    } : {},
     ...populateCache ? {
       populateCache
     } : {}
@@ -2061,6 +2683,9 @@ const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behav
   if (runInitialNetworkQuery) {
     subscription.runInitialNetworkQuery = true;
   }
+  if (runInitialLocalQuery) {
+    subscription.runInitialLocalQuery = true;
+  }
   subscriptions.set(cbKey, subscription);
   let seeded = false;
   if (behavior?.seedSnapshot && updateQuerySubscriptionSnapshot(subscription, behavior.seedSnapshot)) {
@@ -2071,22 +2696,20 @@ const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behav
     callback(subscription.lastSnapshot.error, subscription.lastSnapshot.data, subscription.lastSnapshot.context);
   }
   if (!hadCallbacks) {
-    if (runInitialLocalQuery && !hasPagination) {
-      subscription.hasRequestedInitialLocalQuery = true;
-      requestSubscriptionLocalQuery(cbKey, subscription);
+    if (runInitialLocalQuery) {
+      subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
     }
     sendToServer({
       type: "register-query",
       modelName,
       queryKey,
       query,
-      options,
+      options: getSubscriptionServerOptions(subscription),
       runInitialQuery: runInitialNetworkQuery
     });
   } else {
-    if (runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery && !hasPagination) {
-      subscription.hasRequestedInitialLocalQuery = true;
-      requestSubscriptionLocalQuery(cbKey, subscription);
+    if (runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery) {
+      subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
     }
     if (forceRefreshOnMount || runInitialNetworkQuery && (!hadInitialNetworkQuery || hasSnapshotError(subscription.lastSnapshot))) {
       requestRegisteredQueryRefresh(subscription);
@@ -2097,6 +2720,7 @@ const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behav
     currentSubscription?.callbacks.delete(callback);
     if (currentSubscription && currentSubscription.callbacks.size === 0) {
       subscriptions.delete(cbKey);
+      cancelPendingWindowRequests(cbKey);
       sendToServer({
         type: "remove-query",
         modelName,
@@ -2105,6 +2729,63 @@ const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behav
     }
   };
 };
+const setQueryWindowSize = async ({
+  modelName,
+  query,
+  options,
+  requestedCount,
+  timeoutMs = 1e4
+}) => {
+  const normalizedRequestedCount = normalizeRequestedCount(requestedCount);
+  if (!normalizedRequestedCount || !options.pagination) return false;
+  const queryKey = computeRtsQueryKey(query, options);
+  const cbKey = `${modelName}.${queryKey}`;
+  const subscription = subscriptions.get(cbKey);
+  if (!subscription?.options.pagination) return false;
+  const currentNetworkWindow = subscription.lastSnapshot?.context.source === "network" ? subscription.lastSnapshot.context.window : void 0;
+  if (subscription.requestedCount === normalizedRequestedCount && currentNetworkWindow?.requestedCount === normalizedRequestedCount) {
+    return true;
+  }
+  const previousRequestedCount = subscription.requestedCount ?? subscription.initialWindowSize ?? normalizedRequestedCount;
+  subscription.windowIntentVersion += 1;
+  subscription.requestedCount = normalizedRequestedCount;
+  let request;
+  const response = new Promise((resolve) => {
+    const timeoutId = setRuntimeTimeout(() => {
+      settlePendingWindowRequests(cbKey, request.requestedCount, false);
+    }, timeoutMs);
+    request = {
+      requestedCount: normalizedRequestedCount,
+      previousRequestedCount,
+      resolve,
+      timeoutId
+    };
+    const pending = pendingWindowRequests.get(cbKey) ?? /* @__PURE__ */ new Set();
+    pending.add(request);
+    pendingWindowRequests.set(cbKey, pending);
+  });
+  try {
+    if (!isSocketReady()) {
+      if (!currentTenantId || !currentUid) {
+        settlePendingWindowRequests(cbKey, normalizedRequestedCount, false);
+        return false;
+      }
+      await connectInternal(currentTenantId, currentUid, connectOptions, {
+        resetReconnectAttempts: false
+      });
+    }
+    sendToServer({
+      type: "set-query-window",
+      modelName,
+      queryKey,
+      requestedCount: normalizedRequestedCount
+    });
+  } catch {
+    settlePendingWindowRequests(cbKey, normalizedRequestedCount, false);
+    return false;
+  }
+  return await response;
+};
 const registerCount = (modelName, query, optionsOrCallback, callbackMaybe, behavior) => {
   let options;
   let callback;
@@ -2188,7 +2869,7 @@ const runNetworkQuery = async ({
   }, "runNetworkQuery");
   const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
   const timeoutStartedAt = hasTimeout ? Date.now() : 0;
-  if (!socket || socket.readyState !== WebSocket.OPEN) {
+  if (!isSocketReady()) {
     if (currentTenantId && currentUid) {
       try {
         const connectAttempt = connectInternal(currentTenantId, currentUid, connectOptions, {
@@ -2197,7 +2878,7 @@ const runNetworkQuery = async ({
         if (hasTimeout) {
           await new Promise((resolve, reject) => {
             const timeoutId = setRuntimeTimeout(() => {
-              reject(new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR));
+              reject(new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR));
             }, timeoutMs);
             connectAttempt.then(() => {
               clearRuntimeTimeout(timeoutId);
@@ -2214,7 +2895,7 @@ const runNetworkQuery = async ({
       }
     }
   }
-  if (!socket || socket.readyState !== WebSocket.OPEN) {
+  if (!isSocketReady()) {
     if (hasTimeout && Date.now() - timeoutStartedAt >= timeoutMs) {
       throw new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR);
     }
@@ -2224,7 +2905,7 @@ const runNetworkQuery = async ({
   if (remainingTimeoutMs !== null && remainingTimeoutMs <= 0) {
     throw new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR);
   }
-  const resolvedOptions = options.key ? options : {
+  const resolvedOptions = {
     ...options,
     key: makeRunQueryKey()
   };
@@ -2285,7 +2966,7 @@ const runNetworkCount = async ({
   }
   const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
   const timeoutStartedAt = hasTimeout ? Date.now() : 0;
-  if (!socket || socket.readyState !== WebSocket.OPEN) {
+  if (!isSocketReady()) {
     if (currentTenantId && currentUid) {
       try {
         const connectAttempt = connectInternal(currentTenantId, currentUid, connectOptions, {
@@ -2294,7 +2975,7 @@ const runNetworkCount = async ({
         if (hasTimeout) {
           await new Promise((resolve, reject) => {
             const timeoutId = setRuntimeTimeout(() => {
-              reject(new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR));
+              reject(new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR));
             }, timeoutMs);
             connectAttempt.then(() => {
               clearRuntimeTimeout(timeoutId);
@@ -2311,7 +2992,7 @@ const runNetworkCount = async ({
       }
     }
   }
-  if (!socket || socket.readyState !== WebSocket.OPEN) {
+  if (!isSocketReady()) {
     if (hasTimeout && Date.now() - timeoutStartedAt >= timeoutMs) {
       throw new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR);
     }
@@ -2321,7 +3002,7 @@ const runNetworkCount = async ({
   if (remainingTimeoutMs !== null && remainingTimeoutMs <= 0) {
     throw new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR);
   }
-  const resolvedOptions = options.key ? options : {
+  const resolvedOptions = {
     ...options,
     key: makeRunQueryKey()
   };
@@ -2432,28 +3113,9 @@ const normalizeTotalCount = (value) => {
   if (!Number.isFinite(value) || value < 0) return void 0;
   return Math.floor(value);
 };
-const getDocId = (doc) => {
-  if (!doc || typeof doc !== "object") return "";
-  const id = doc._id;
-  return typeof id === "string" ? id.trim() : "";
-};
-const dedupeById = (docs) => {
-  const seen = /* @__PURE__ */ new Set();
-  const merged = [];
-  for (const doc of docs) {
-    const id = getDocId(doc);
-    if (id && seen.has(id)) continue;
-    if (id) seen.add(id);
-    merged.push(doc);
-  }
-  return merged;
-};
-const flattenLoadedPages = (previousPages, headPage, nextPages) => {
-  const merged = [];
-  for (const page of previousPages) merged.push(...page.nodes);
-  if (headPage) merged.push(...headPage.nodes);
-  for (const page of nextPages) merged.push(...page.nodes);
-  return dedupeById(merged);
+const normalizeWindowSize = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 1;
+  return Math.max(1, Math.min(RTS_QUERY_WINDOW_MAX_COUNT, Math.floor(value)));
 };
 const assertIncludeOnlyProjection = (projection) => {
   if (!projection) return;
@@ -2484,6 +3146,13 @@ const useQuery = (modelName, query = {}, options = {}) => {
     populate: options.populate
   }, "useQuery");
   const isPaginated = Boolean(options.pagination);
+  if (options.pagination && (!Number.isInteger(options.pagination.limit) || options.pagination.limit < 1 || options.pagination.limit > RTS_QUERY_WINDOW_MAX_COUNT)) {
+    throw new Error("useQuery: pagination limit must be an integer between 1 and 4096");
+  }
+  if (options.pagination?.cursor || options.pagination?.direction) {
+    throw new Error("useQuery: cursor and direction are not supported by virtual query windows");
+  }
+  const initialWindowSize = isPaginated ? normalizeWindowSize(options.pagination?.limit) : void 0;
   const queryKey = computeRtsQueryKey(query, {
     key,
     projection: options.projection,
@@ -2513,7 +3182,7 @@ const useQuery = (modelName, query = {}, options = {}) => {
   const seedTotalCountRaw = useMemo(() => enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getQueryTotalCount(modelName, queryKey) : peekHydratedRtsQueryTotalCount(modelName, queryKey) : void 0, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey]);
   const hasSeedData = Array.isArray(seedDataRaw);
   const seedData = hasSeedData ? seedDataRaw : void 0;
-  const seedPageInfo = normalizePageInfo(seedPageInfoRaw);
+  const seedPageInfo = useMemo(() => normalizePageInfo(seedPageInfoRaw), [seedPageInfoRaw]);
   const seedTotalCount = normalizeTotalCount(seedTotalCountRaw);
   const seedJson = (() => {
     if (!hasSeedData) return "";
@@ -2533,38 +3202,21 @@ const useQuery = (modelName, query = {}, options = {}) => {
   })();
   const seedTotalCountStr = seedTotalCount !== void 0 ? String(seedTotalCount) : "";
   const [data, setData] = useState(() => isPaginated ? void 0 : seedData);
-  const [headPage, setHeadPage] = useState(() => isPaginated && seedData ? {
-    nodes: seedData,
-    ...seedPageInfo ? {
-      pageInfo: seedPageInfo
-    } : {}
-  } : null);
+  const [paginatedData, setPaginatedData] = useState(() => isPaginated ? seedData : void 0);
+  const [pageInfo, setPageInfo] = useState(() => isPaginated ? seedPageInfo : void 0);
   const [totalCount, setTotalCount] = useState(() => isPaginated ? seedTotalCount : void 0);
-  const [previousPages, setPreviousPages] = useState([]);
-  const [nextPages, setNextPages] = useState([]);
   const [source, setSource] = useState(() => hasSeedData ? "cache" : void 0);
   const [error, setError] = useState(void 0);
   const [loading, setLoading] = useState(enabled && !hasSeedData);
-  const [pagingDirection, setPagingDirection] = useState(null);
   const hasFirstReply = useRef(false);
   const hasNetworkReply = useRef(false);
   const lastDataJsonRef = useRef("");
-  const previousPagesRef = useRef([]);
-  const nextPagesRef = useRef([]);
-  const headPageRef = useRef(null);
-  const pagingDirectionRef = useRef(null);
+  const pageInfoRef = useRef(seedPageInfo);
+  const requestedCountRef = useRef(initialWindowSize ?? 1);
+  const pagingRef = useRef(false);
   useEffect(() => {
-    previousPagesRef.current = previousPages;
-  }, [previousPages]);
-  useEffect(() => {
-    nextPagesRef.current = nextPages;
-  }, [nextPages]);
-  useEffect(() => {
-    headPageRef.current = headPage;
-  }, [headPage]);
-  useEffect(() => {
-    pagingDirectionRef.current = pagingDirection;
-  }, [pagingDirection]);
+    pageInfoRef.current = pageInfo;
+  }, [pageInfo]);
   useEffect(() => {
     if (!ssrRuntime && enabled && ssrEnabled && hasSeedData) {
       consumeHydratedRtsQueryData(modelName, queryKey);
@@ -2572,13 +3224,14 @@ const useQuery = (modelName, query = {}, options = {}) => {
     hasFirstReply.current = hasSeedData;
     hasNetworkReply.current = false;
     lastDataJsonRef.current = seedJson;
+    requestedCountRef.current = initialWindowSize ?? 1;
+    pagingRef.current = false;
     setError(void 0);
-    setPreviousPages([]);
-    setNextPages([]);
     if (!enabled) {
       setLoading(false);
       setData(void 0);
-      setHeadPage(null);
+      setPaginatedData(void 0);
+      setPageInfo(void 0);
       setTotalCount(void 0);
       setSource(void 0);
       return;
@@ -2588,30 +3241,28 @@ const useQuery = (modelName, query = {}, options = {}) => {
       setLoading(false);
       setSource("cache");
       if (isPaginated) {
-        setHeadPage({
-          nodes: nextSeedData,
-          ...seedPageInfo ? {
-            pageInfo: seedPageInfo
-          } : {}
-        });
+        setPaginatedData(nextSeedData);
+        setPageInfo(seedPageInfo);
         setTotalCount(seedTotalCount);
         setData(void 0);
       } else {
         setData(nextSeedData);
         setTotalCount(void 0);
-        setHeadPage(null);
+        setPaginatedData(void 0);
+        setPageInfo(void 0);
       }
       return;
     }
     setData(void 0);
-    setHeadPage(null);
+    setPaginatedData(void 0);
+    setPageInfo(void 0);
     setTotalCount(void 0);
     setLoading(true);
-  }, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey, hasSeedData, seedJson, seedPageInfoJson, seedTotalCountStr, isPaginated]);
+  }, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey, hasSeedData, seedData, seedJson, seedPageInfo, seedPageInfoJson, seedTotalCount, seedTotalCountStr, isPaginated, initialWindowSize]);
   useEffect(() => {
     if (!enabled) return;
-    const runInitialNetworkQuery = refreshOnMount || !hasSeedData;
-    const runInitialLocalQuery = !hasSeedData && !isPaginated;
+    const runInitialNetworkQuery = isPaginated || refreshOnMount || !hasSeedData;
+    const runInitialLocalQuery = !hasSeedData;
     const unsubscribe = registerQuery(modelName, query, {
       key,
       projection: options.projection,
@@ -2620,7 +3271,23 @@ const useQuery = (modelName, query = {}, options = {}) => {
       populate: options.populate,
       pagination: options.pagination
     }, (err, result, context) => {
-      if (context.source === "cache" && hasNetworkReply.current) return;
+      if (context.source === "cache" && context.reset) {
+        hasFirstReply.current = false;
+        hasNetworkReply.current = false;
+        lastDataJsonRef.current = "";
+        pageInfoRef.current = void 0;
+        requestedCountRef.current = initialWindowSize ?? 1;
+        pagingRef.current = false;
+        setData(void 0);
+        setPaginatedData(void 0);
+        setPageInfo(void 0);
+        setTotalCount(void 0);
+        setSource(void 0);
+        setError(void 0);
+        setLoading(true);
+        return;
+      }
+      if (context.source === "cache" && hasNetworkReply.current && (!isPaginated || !context.window || context.window.requestedCount <= requestedCountRef.current)) return;
       if (context.source === "network") {
         hasNetworkReply.current = true;
       }
@@ -2636,10 +3303,15 @@ const useQuery = (modelName, query = {}, options = {}) => {
       hasFirstReply.current = true;
       const nextPageInfo = context.pageInfo;
       const nextTotalCount = context.totalCount;
+      const nextRequestedCount = context.window?.requestedCount;
+      if (isPaginated && nextRequestedCount !== void 0) {
+        requestedCountRef.current = nextRequestedCount;
+      }
       const payloadForHash = isPaginated ? {
         result,
         pageInfo: nextPageInfo,
-        totalCount: nextTotalCount
+        totalCount: nextTotalCount,
+        requestedCount: nextRequestedCount
       } : result;
       let nextJson = "";
       try {
@@ -2655,13 +3327,9 @@ const useQuery = (modelName, query = {}, options = {}) => {
       setSource(context.source);
       setError(void 0);
       if (isPaginated) {
-        setHeadPage({
-          nodes: result,
-          ...nextPageInfo ? {
-            pageInfo: nextPageInfo
-          } : {}
-        });
-        setTotalCount((current) => nextTotalCount === void 0 ? current : nextTotalCount);
+        setPaginatedData(result);
+        setPageInfo(nextPageInfo);
+        setTotalCount(nextTotalCount);
         return;
       }
       setData(result);
@@ -2681,6 +3349,11 @@ const useQuery = (modelName, query = {}, options = {}) => {
             } : {},
             ...seedTotalCount !== void 0 ? {
               totalCount: seedTotalCount
+            } : {},
+            ...initialWindowSize ? {
+              window: {
+                requestedCount: initialWindowSize
+              }
             } : {}
           }
         }
@@ -2689,45 +3362,18 @@ const useQuery = (modelName, query = {}, options = {}) => {
     return () => {
       unsubscribe?.();
     };
-  }, [enabled, modelName, queryKey, queryJson, projectionJson, sortJson, limitStr, populateJson, paginationJson, hasSeedData, refreshOnMount, isPaginated]);
-  const effectivePageInfo = useMemo(() => {
-    if (!isPaginated) return void 0;
-    const firstPageInfo = previousPages.length > 0 ? previousPages[0]?.pageInfo : headPage?.pageInfo;
-    const lastPageInfo = nextPages.length > 0 ? nextPages[nextPages.length - 1]?.pageInfo : headPage?.pageInfo;
-    if (!firstPageInfo && !lastPageInfo) return void 0;
-    const hasPrevPage = Boolean(firstPageInfo?.hasPrevPage);
-    const hasNextPage = Boolean(lastPageInfo?.hasNextPage);
-    const prevCursor = firstPageInfo?.prevCursor;
-    const nextCursor = lastPageInfo?.nextCursor;
-    return {
-      hasPrevPage,
-      hasNextPage,
-      ...prevCursor ? {
-        prevCursor
-      } : {},
-      ...nextCursor ? {
-        nextCursor
-      } : {}
-    };
-  }, [headPage, isPaginated, nextPages, previousPages]);
-  const mergedPaginatedData = useMemo(() => {
-    if (!isPaginated) return void 0;
-    if (!headPage && previousPages.length === 0 && nextPages.length === 0) return void 0;
-    return flattenLoadedPages(previousPages, headPage, nextPages);
-  }, [headPage, isPaginated, nextPages, previousPages]);
+  }, [enabled, modelName, queryKey, queryJson, projectionJson, sortJson, limitStr, populateJson, paginationJson, hasSeedData, refreshOnMount, isPaginated, initialWindowSize]);
   const fetchNext = async () => {
     if (!enabled || !isPaginated || !options.pagination) return false;
-    if (pagingDirectionRef.current) return false;
-    const currentHead = headPageRef.current;
-    const currentNextPages = nextPagesRef.current;
-    const cursor = currentNextPages.length > 0 ? currentNextPages[currentNextPages.length - 1]?.pageInfo?.nextCursor : currentHead?.pageInfo?.nextCursor;
-    const hasNextPage_0 = currentNextPages.length > 0 ? Boolean(currentNextPages[currentNextPages.length - 1]?.pageInfo?.hasNextPage) : Boolean(currentHead?.pageInfo?.hasNextPage);
-    if (!cursor || !hasNextPage_0) return false;
-    setPagingDirection("next");
+    if (pagingRef.current || !pageInfoRef.current?.hasNextPage) return false;
+    const pageSize = initialWindowSize ?? normalizeWindowSize(options.pagination.limit);
+    const nextRequestedCount_0 = Math.min(RTS_QUERY_WINDOW_MAX_COUNT, requestedCountRef.current + pageSize);
+    if (nextRequestedCount_0 === requestedCountRef.current) return false;
+    pagingRef.current = true;
     setLoading(true);
     setError(void 0);
     try {
-      const response = await runNetworkQuery({
+      return await setQueryWindowSize({
         modelName,
         query,
         options: {
@@ -2736,91 +3382,47 @@ const useQuery = (modelName, query = {}, options = {}) => {
           sort: options.sort,
           limit: options.limit,
           populate: options.populate,
-          pagination: {
-            ...options.pagination,
-            direction: "next",
-            cursor
-          }
-        }
+          pagination: options.pagination
+        },
+        requestedCount: nextRequestedCount_0
       });
-      if (!Array.isArray(response.data)) return false;
-      const page = {
-        nodes: response.data,
-        ...response.context.source === "network" && response.context.pageInfo ? {
-          pageInfo: response.context.pageInfo
-        } : {}
-      };
-      setSource("network");
-      if (response.context.source === "network" && response.context.totalCount !== void 0) {
-        setTotalCount(response.context.totalCount);
-      }
-      setNextPages((current_0) => [...current_0, page]);
-      return true;
     } catch (err_0) {
       setError(err_0);
       return false;
     } finally {
-      setPagingDirection(null);
+      pagingRef.current = false;
       setLoading(false);
     }
   };
   const fetchPrevious = async () => {
-    if (!enabled || !isPaginated || !options.pagination) return false;
-    if (pagingDirectionRef.current) return false;
-    const currentHead_0 = headPageRef.current;
-    const currentPreviousPages = previousPagesRef.current;
-    const cursor_0 = currentPreviousPages.length > 0 ? currentPreviousPages[0]?.pageInfo?.prevCursor : currentHead_0?.pageInfo?.prevCursor;
-    const hasPrevPage_0 = currentPreviousPages.length > 0 ? Boolean(currentPreviousPages[0]?.pageInfo?.hasPrevPage) : Boolean(currentHead_0?.pageInfo?.hasPrevPage);
-    if (!cursor_0 || !hasPrevPage_0) return false;
-    setPagingDirection("prev");
+    return false;
+  };
+  const resetPagination = () => {
+    if (!enabled || !isPaginated || !options.pagination || !initialWindowSize) return;
+    if (pagingRef.current || requestedCountRef.current === initialWindowSize) return;
+    pagingRef.current = true;
     setLoading(true);
     setError(void 0);
-    try {
-      const response_0 = await runNetworkQuery({
-        modelName,
-        query,
-        options: {
-          key,
-          projection: options.projection,
-          sort: options.sort,
-          limit: options.limit,
-          populate: options.populate,
-          pagination: {
-            ...options.pagination,
-            direction: "prev",
-            cursor: cursor_0
-          }
-        }
-      });
-      if (!Array.isArray(response_0.data)) return false;
-      const page_0 = {
-        nodes: response_0.data,
-        ...response_0.context.source === "network" && response_0.context.pageInfo ? {
-          pageInfo: response_0.context.pageInfo
-        } : {}
-      };
-      setSource("network");
-      if (response_0.context.source === "network" && response_0.context.totalCount !== void 0) {
-        setTotalCount(response_0.context.totalCount);
-      }
-      setPreviousPages((current_1) => [page_0, ...current_1]);
-      return true;
-    } catch (err_1) {
-      setError(err_1);
-      return false;
-    } finally {
-      setPagingDirection(null);
+    void setQueryWindowSize({
+      modelName,
+      query,
+      options: {
+        key,
+        projection: options.projection,
+        sort: options.sort,
+        limit: options.limit,
+        populate: options.populate,
+        pagination: options.pagination
+      },
+      requestedCount: initialWindowSize
+    }).finally(() => {
+      pagingRef.current = false;
       setLoading(false);
-    }
-  };
-  const resetPagination = () => {
-    if (!isPaginated) return;
-    setPreviousPages([]);
-    setNextPages([]);
+    });
   };
-  return useMemo(() => ({
-    data: isPaginated ? mergedPaginatedData : data,
-    pageInfo: effectivePageInfo,
+  return {
+    data: isPaginated ? paginatedData : data,
+    pageInfo: isPaginated ? pageInfo : void 0,
     totalCount: isPaginated ? totalCount : void 0,
     source,
     error,
@@ -2828,7 +3430,7 @@ const useQuery = (modelName, query = {}, options = {}) => {
     fetchNext,
     fetchPrevious,
     resetPagination
-  }), [data, effectivePageInfo, error, fetchNext, fetchPrevious, isPaginated, loading, mergedPaginatedData, source, totalCount]);
+  };
 };
 export {
   registerQuery as A,
@@ -2869,4 +3471,4 @@ export {
   onMessage as y,
   onRtsMessage as z
 };
-//# sourceMappingURL=useQuery-BOjtIBwv.js.map
+//# sourceMappingURL=useQuery-DZqYIJog.js.map