@rebasepro/client 0.13.0 → 0.13.1-canary.g249daa1

package/src/collection.ts

@@ -9,12 +9,19 @@ import {
     SDKQueryBuilderInterface,
     WhereFilterOp,
     WhereValue,
-    WriteOptions
+    WriteOptions,
+    type ComputedSortField
 } from "@rebasepro/types";
-import { collectAllPages, paginateFind } from "@rebasepro/common";
+import { collectAllPages, paginateFind, resolveFindWindow } from "@rebasepro/common";
 
 import { SDKQueryBuilder } from "./sdk_query_builder";
 
+/**
+ * Counts currently in flight, keyed by the exact request they issue. Entries
+ * live only for the duration of the request — see `count()` for why.
+ */
+const inflightCounts = new Map<string, Promise<number>>();
+
 /**
  * A live query result: a normal {@link FindResult} plus what an interface
  * needs to decide whether to show a "saving…" or "offline" affordance over it.
@@ -155,7 +162,7 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             return raw as M;
         },
 
-        async createMany(data: Partial<M>[], options?: { upsert?: boolean }) {
+        async createMany(data: Partial<M>[], options?: { upsert?: boolean } & WriteOptions) {
             if (!Array.isArray(data)) {
                 throw new TypeError("createMany expects an array of records.");
             }
@@ -166,11 +173,29 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
                 body: JSON.stringify({
                     rows: data,
                     ...(options?.upsert ? { upsert: true } : {})
-                })
+                }),
+                ...(options?.idempotencyKey
+                    ? { headers: { "Idempotency-Key": options.idempotencyKey } }
+                    : {})
             });
             return (raw.data || []) as M[];
         },
 
+        /**
+         * Still `PUT`, deliberately, even though the server now serves `PATCH`
+         * on the same handler and `PATCH` is the honest verb for a merge.
+         *
+         * The two are interchangeable server-side, so switching buys nothing at
+         * runtime — and it costs compatibility in the direction that fails
+         * quietly. A 0.14 client talking to a 0.13 server would send `PATCH` to
+         * a route that does not exist and get a **404**, which is
+         * indistinguishable from "that row is gone". Every write would look like
+         * a missing record.
+         *
+         * `PATCH` is what the OpenAPI spec advertises, so anyone generating a
+         * client gets the correct verb; this stays on `PUT` until the oldest
+         * supported server is one that serves both.
+         */
         async update(id: string | number, data: Partial<M>) {
             const raw = await transport.request<Record<string, unknown>>(`${basePath}/${encodeURIComponent(String(id))}`, {
                 method: "PUT",
@@ -179,12 +204,54 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             return raw as M;
         },
 
+        async updateMany(updates: { id: string | number; data: Partial<M> }[], options?: WriteOptions) {
+            if (!Array.isArray(updates)) {
+                throw new TypeError("updateMany expects an array of { id, data } entries.");
+            }
+            if (updates.length === 0) return [];
+
+            const raw = await transport.request<{ data: Record<string, unknown>[] }>(`${basePath}/bulk`, {
+                method: "PATCH",
+                body: JSON.stringify({ updates }),
+                ...(options?.idempotencyKey
+                    ? { headers: { "Idempotency-Key": options.idempotencyKey } }
+                    : {})
+            });
+            return (raw.data || []) as M[];
+        },
+
         async delete(id: string | number) {
             await transport.request<void>(`${basePath}/${encodeURIComponent(String(id))}`, {
                 method: "DELETE"
             });
         },
 
+        /**
+         * `POST .../bulk/delete`, not `DELETE .../bulk`.
+         *
+         * The honest verb would take the ids in a DELETE body, and that is the
+         * one request shape the HTTP ecosystem handles unreliably: bodies on
+         * DELETE are permitted but widely dropped by proxies and CDNs, and
+         * several OpenAPI generators ignore `requestBody` on a DELETE
+         * operation, so a generated client would send the request without its
+         * ids. A backend deployed behind arbitrary ingress cannot take that
+         * bet. Same reason `:batchDelete` exists in Google's API guidelines.
+         */
+        async deleteMany(ids: (string | number)[], options?: WriteOptions) {
+            if (!Array.isArray(ids)) {
+                throw new TypeError("deleteMany expects an array of ids.");
+            }
+            if (ids.length === 0) return;
+
+            await transport.request<void>(`${basePath}/bulk/delete`, {
+                method: "POST",
+                body: JSON.stringify({ ids }),
+                ...(options?.idempotencyKey
+                    ? { headers: { "Idempotency-Key": options.idempotencyKey } }
+                    : {})
+            });
+        },
+
         async count(params?: FindParams<M>): Promise<number> {
             const countParams: FindParams<M> = {
                 ...params,
@@ -198,8 +265,34 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
                 include: undefined
             };
             const qs = buildQueryString(countParams);
-            const raw = await transport.request<{ count: number }>(basePath + "/count" + qs, { method: "GET" });
-            return raw.count ?? 0;
+
+            // One count per query in flight, not one per caller.
+            //
+            // A count is a property of the query, and every concurrent caller
+            // asking the same question wants the same answer — so they can
+            // share the one request. This is not a micro-optimisation: a live
+            // subscription re-counts on every push (see `listen` below), and
+            // `listenCollection` deliberately collapses identical queries onto
+            // a single socket subscription while keeping one callback per
+            // subscriber. Each push therefore woke N subscribers, and each of
+            // them issued its own identical count. A table showing one relation
+            // column fired one count per visible cell, on every update.
+            //
+            // The entry is dropped as soon as it settles, so this merges
+            // concurrent calls only and never serves a cached total.
+            const key = basePath + "/count" + qs;
+            const inflight = inflightCounts.get(key);
+            if (inflight) return inflight;
+
+            const request = transport
+                .request<{ count: number }>(key, { method: "GET" })
+                .then((raw) => raw.count ?? 0);
+            inflightCounts.set(key, request);
+            try {
+                return await request;
+            } finally {
+                inflightCounts.delete(key);
+            }
         },
 
         // Reactive reads. Without the offline layer there is no local database
@@ -212,15 +305,36 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             options?: ObserveOptions
         ) {
             let closed = false;
-            const emit = (result: FindResult<M>) => {
+            // Two sources race into one callback: the one-shot fetch below and
+            // the subscription beside it. Whichever resolves last used to win,
+            // so a socket update that landed first was overwritten by the
+            // fetch's older snapshot and stayed wrong until the next change.
+            // `listenCollection` replays cached rows synchronously to a second
+            // subscriber, so a second component observing the same query hit
+            // that ordering every time.
+            let liveDelivered = false;
+            let signature: string | undefined;
+
+            const deliver = (result: FindResult<M>, fromLive: boolean) => {
                 if (closed) return;
+                // Once the socket has spoken, the fetch issued alongside it is
+                // older news — delivering it would move the app backwards.
+                if (fromLive) liveDelivered = true;
+                else if (liveDelivered) return;
+                // The de-duplication `observe()` documents. Keyed on the rows
+                // and the total, the same two things the offline layer keys on,
+                // so both implementations mean the same thing by "changed".
+                const next = `${result.meta?.total ?? ""}|${JSON.stringify(result.data)}`;
+                if (signature !== undefined && next === signature) return;
+                signature = next;
                 onResult({ ...result, fromCache: false, hasPendingWrites: false, partial: false });
             };
-            client.find(params).then(emit).catch((error) => {
+
+            client.find(params).then((result) => deliver(result, false)).catch((error) => {
                 if (!closed) onError?.(error as Error);
             });
             const live = options?.realtime !== false && client.listen
-                ? client.listen(params, emit, onError)
+                ? client.listen(params, (result) => deliver(result, true), onError)
                 : undefined;
             return () => {
                 closed = true;
@@ -235,15 +349,25 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             options?: ObserveOptions
         ) {
             let closed = false;
-            const emit = (row: M | undefined) => {
+            let liveDelivered = false;
+            let signature: string | undefined;
+
+            // Same ordering and de-duplication rules as `observe`, for one row.
+            const deliver = (row: M | undefined, fromLive: boolean) => {
                 if (closed) return;
+                if (fromLive) liveDelivered = true;
+                else if (liveDelivered) return;
+                const next = row === undefined ? "\u0000missing" : JSON.stringify(row);
+                if (signature !== undefined && next === signature) return;
+                signature = next;
                 onResult(row, { fromCache: false, hasPendingWrites: false });
             };
-            client.findById(id).then(emit).catch((error) => {
+
+            client.findById(id).then((row) => deliver(row, false)).catch((error) => {
                 if (!closed) onError?.(error as Error);
             });
             const live = options?.realtime !== false && client.listenById
-                ? client.listenById(id, emit, onError)
+                ? client.listenById(id, (row) => deliver(row, true), onError)
                 : undefined;
             return () => {
                 closed = true;
@@ -259,7 +383,7 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
             }
             return builder.where(columnOrCondition as keyof M & string, operator!, value as WhereValue<M[keyof M & string]>);
         },
-        orderBy(column: keyof M & string, direction?: "asc" | "desc") {
+        orderBy(column: (keyof M & string) | ComputedSortField, direction?: "asc" | "desc") {
             return new SDKQueryBuilder<M>(client).orderBy(column, direction);
         },
         limit(count: number) {
@@ -268,8 +392,15 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
         offset(count: number) {
             return new SDKQueryBuilder<M>(client).offset(count);
         },
-        search(searchString: string) {
-            return new SDKQueryBuilder<M>(client).search(searchString);
+        search(searchString: string, options?: { explain?: boolean }) {
+            return new SDKQueryBuilder<M>(client).search(searchString, options);
+        },
+        vectorSearch(
+            property: string,
+            vector: number[],
+            options?: { distance?: "cosine" | "l2" | "inner_product"; threshold?: number }
+        ) {
+            return new SDKQueryBuilder<M>(client).vectorSearch(property, vector, options);
         },
         include(...relations: string[]) {
             return new SDKQueryBuilder<M>(client).include(...relations);
@@ -280,69 +411,81 @@ export function createCollectionClient<M extends Record<string, unknown> = Recor
         client.listen = (params: FindParams<M> | undefined, onUpdate: (response: FindResult<M>) => void, onError?: (error: Error) => void) => {
             let active = true;
             let lastUpdateId = 0;
+            // The last total a `count()` actually returned. A later count that
+            // fails says nothing about how big the collection is, so it must
+            // not be allowed to replace this with the length of one page.
+            let lastKnownTotal: number | undefined;
+            const window = resolveFindWindow(params);
             const unsub = ws.listenCollection(
                 {
                     path: slug,
                     filter: params?.where,
+                    // The group used to be dropped here, so a subscription
+                    // filtered with `or(...)` was pushed every row instead.
+                    logical: params?.logical,
                     limit: params?.limit,
-                    startAfter: params?.offset ? String(params.offset) : undefined,
+                    // `offset` used to be stringified into `startAfter`, which
+                    // is a cursor *row*, not a row count — so the server was
+                    // handed "20" where it expected a keyset value, and the
+                    // offset it does understand never arrived at all.
+                    offset: window.driverOffset,
                     orderBy: params?.orderBy?.[0],
                     order: params?.orderBy?.[1],
-                    searchString: params?.searchString
+                    searchString: params?.searchString,
+                    searchExplain: params?.searchExplain
                 },
                 (incomingRows: Record<string, unknown>[]) => {
                     const currentUpdateId = ++lastUpdateId;
-                    const requestedLimit = params?.limit || 20;
-                    const offset = params?.offset || 0;
+                    // What the server pages by when the caller names no limit.
+                    // A hardcoded 20 here described a window the rows had not
+                    // come from, and any app sizing its next request off
+                    // `meta.limit` was told the wrong number.
+                    const requestedLimit = window.limit;
+                    const offset = window.offset;
 
                     // WS client already delivers flat rows — just cast
                     const rows = incomingRows as M[];
 
-                    // Heuristic metadata (used as fallback if count call fails)
-                    const heuristicTotal = rows.length;
-                    const heuristicHasMore = rows.length >= requestedLimit;
+                    const emit = (total: number, hasMore: boolean) => {
+                        if (!active || currentUpdateId !== lastUpdateId) return;
+                        onUpdate({
+                            data: rows,
+                            meta: {
+                                total,
+                                limit: requestedLimit,
+                                offset,
+                                hasMore
+                            }
+                        });
+                    };
+
+                    // With no count to go on, the only defensible total is a
+                    // lower bound: the rows on this page plus the ones paged
+                    // past to reach them. Reporting `rows.length` claimed a
+                    // collection read at offset 10 held two rows.
+                    const emitWithoutCount = () => emit(
+                        offset + rows.length,
+                        rows.length >= requestedLimit
+                    );
 
-                    // Try to get authoritative count; fall back to heuristic
                     if (client.count) {
                         client.count(params)
                             .then((total) => {
-                                if (active && currentUpdateId === lastUpdateId) {
-                                    onUpdate({
-                                        data: rows,
-                                        meta: {
-                                            total,
-                                            limit: requestedLimit,
-                                            offset,
-                                            hasMore: offset + rows.length < total
-                                        }
-                                    });
-                                }
+                                lastKnownTotal = total;
+                                emit(total, offset + rows.length < total);
                             })
                             .catch(() => {
-                                // Count failed — use heuristic meta
-                                if (active && currentUpdateId === lastUpdateId) {
-                                    onUpdate({
-                                        data: rows,
-                                        meta: {
-                                            total: heuristicTotal,
-                                            limit: requestedLimit,
-                                            offset,
-                                            hasMore: heuristicHasMore
-                                        }
-                                    });
+                                // A count that failed is not evidence about the
+                                // size of the collection. Keep the last real
+                                // answer; only guess if there has never been one.
+                                if (lastKnownTotal !== undefined) {
+                                    emit(lastKnownTotal, offset + rows.length < lastKnownTotal);
+                                } else {
+                                    emitWithoutCount();
                                 }
                             });
                     } else {
-                        // No count method — fire immediately with heuristic meta
-                        onUpdate({
-                            data: rows,
-                            meta: {
-                                total: heuristicTotal,
-                                limit: requestedLimit,
-                                offset,
-                                hasMore: heuristicHasMore
-                            }
-                        });
+                        emitWithoutCount();
                     }
                 },
                 onError

package/src/index.ts

@@ -42,6 +42,9 @@ import { toSnakeCase } from "@rebasepro/utils";
 // data-proxy's unknown-collection error.
 export { RebaseApiError } from "./transport";
 export { RebaseClientError } from "./errors";
+// The codes `RebaseApiError.code` carries. An open union — routes add their own
+// — so it gives completion on the common ones without pretending to be closed.
+export type { RebaseErrorCode } from "@rebasepro/types";
 
 // Query + collection types (annotate SDK results; construct via the fluent API).
 export type { RebaseClientConfig, FindParams, FindResponse } from "./transport";
@@ -238,35 +241,48 @@ export type CreateRebaseClientResult<DB = Record<string, unknown>> = Omit<Rebase
 /**
  * Derive a WebSocket URL from an HTTP base URL.
  * `http://` → `ws://`, `https://` → `wss://`.
+ *
+ * A backend mounted under a path is the reason `baseUrl` accepts one, so the
+ * path is kept. It used to be kept for an absolute `baseUrl` and dropped for a
+ * relative one — resolved through `.origin` — so one deployment dialled two
+ * different sockets depending on whether its config said `"/backend"` or
+ * `"https://app.example.com/backend"`.
+ *
+ * Returns `""` when there is nothing to resolve against: a relative `baseUrl`
+ * outside a browser has no origin, and inventing one would dial somewhere
+ * arbitrary. The caller warns rather than leaving that silent.
  */
 function deriveWebSocketUrl(baseUrl?: string): string {
+    const toWsProtocol = (url: string): string => {
+        const secure = /^(https|wss):/i.test(url);
+        return url
+            .replace(/^https?:\/\//i, secure ? "wss://" : "ws://")
+            .replace(/^wss?:\/\//i, secure ? "wss://" : "ws://")
+            .replace(/\/$/, "");
+    };
+
     if (typeof window !== "undefined") {
-        let absoluteUrl = "";
+        let absoluteUrl: string;
         if (!baseUrl) {
             absoluteUrl = window.location.origin;
         } else if (/^https?:\/\//i.test(baseUrl) || /^wss?:\/\//i.test(baseUrl)) {
             absoluteUrl = baseUrl;
         } else {
             try {
-                absoluteUrl = new URL(baseUrl, window.location.href).origin;
+                const resolved = new URL(baseUrl, window.location.href);
+                absoluteUrl = resolved.origin + resolved.pathname;
             } catch {
                 absoluteUrl = window.location.origin;
             }
         }
-        const protocol = absoluteUrl.startsWith("https:") || absoluteUrl.startsWith("wss:") ? "wss:" : "ws:";
-        return absoluteUrl
-            .replace(/^https?:\/\//i, `${protocol}//`)
-            .replace(/^wss?:\/\//i, `${protocol}//`)
-            .replace(/\/$/, "");
+        return toWsProtocol(absoluteUrl);
     }
 
     if (!baseUrl) return "";
     if (!/^https?:\/\//i.test(baseUrl) && !/^wss?:\/\//i.test(baseUrl)) {
         return "";
     }
-    return baseUrl
-        .replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://")
-        .replace(/\/$/, "");
+    return toWsProtocol(baseUrl);
 }
 
 export function createRebaseClient<DB = Record<string, unknown>>(options: CreateRebaseClientOptions): CreateRebaseClientResult<DB> {
@@ -332,6 +348,24 @@ export function createRebaseClient<DB = Record<string, unknown>>(options: Create
         ? (options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl))
         : undefined;
 
+    // Realtime is on unless it was switched off, so "on, but no URL could be
+    // derived" is a misconfiguration and not a choice. It used to be silent:
+    // the client simply had no socket, `observe()` quietly degraded to a
+    // one-shot fetch, and `realtime.channel()` blamed `realtime: false` — an
+    // option the caller had not passed.
+    const realtimeUnreachable = realtimeEnabled && !resolvedWsUrl;
+    const unreachableReason =
+        "no WebSocket URL could be derived from baseUrl " +
+        `${JSON.stringify(options.baseUrl ?? null)} — outside a browser there is no page origin ` +
+        "to resolve a relative URL against. Pass an absolute `baseUrl`, set `websocketUrl` " +
+        "explicitly, or pass `realtime: false` to say this was intended.";
+    if (realtimeUnreachable) {
+        console.warn(
+            `[Rebase] Realtime is enabled but ${unreachableReason} ` +
+            "Live queries will fall back to a single fetch and channels will throw."
+        );
+    }
+
     let ws: RebaseWebSocketClient | undefined;
     /** One channel object per name — see `realtime.channel`. */
     const realtimeChannels = new Map<string, RebaseRealtimeChannel>();
@@ -529,13 +563,15 @@ export function createRebaseClient<DB = Record<string, unknown>>(options: Create
              * cut off the others.
              */
             channel: (name: string, options?: ChannelOptions): RebaseRealtimeChannel => {
-                // Only `realtime: false` gets here — a hard opt-out, so this
-                // stays an error. Being merely *unconnected* does not: the
-                // socket opens on the first channel operation, which is the
-                // whole point of asking for a channel before you use one.
+                // Being merely *unconnected* is not an error: the socket opens
+                // on the first channel operation, which is the whole point of
+                // asking for a channel before you use one. Having no socket at
+                // all is, and there are two reasons for it — say which.
                 if (!ws) {
                     throw new RebaseClientError(
-                        "Realtime is disabled on this client (realtime: false), so channels are unavailable."
+                        realtimeUnreachable
+                            ? `Realtime is enabled but ${unreachableReason}`
+                            : "Realtime is disabled on this client (realtime: false), so channels are unavailable."
                     );
                 }
                 let existing = realtimeChannels.get(name);

package/src/like-pattern-redos.test.ts

@@ -0,0 +1,61 @@
+import { matchesOperator } from "./offline-query";
+
+/**
+ * A `like` pattern is user input, and it becomes a regular expression.
+ *
+ * `%` translates to `[\s\S]*`, so `%%%%X` becomes four adjacent unbounded
+ * quantifiers followed by a literal. On a subject that does not match, the
+ * engine has to try every way of splitting the subject between them — which is
+ * exponential. Twelve `%` against a forty-character value took **100 seconds**
+ * on this machine before answering `false`.
+ *
+ * The pattern arrives over HTTP: `?title=like.%25%25%25…` is a public filter
+ * operator, listed in the operator table. On the offline evaluator that freezes
+ * the tab; the same translation in the Mongo driver hands the expression to the
+ * database, where it occupies a server thread instead.
+ *
+ * Consecutive `%` mean exactly what one `%` means, so collapsing a run is
+ * semantics-preserving and removes the ambiguity the backtracking feeds on.
+ */
+const HOSTILE = "%".repeat(14) + "X";
+const SUBJECT = "a".repeat(48);
+
+describe("like patterns cannot be made to backtrack", () => {
+    it("answers a hostile pattern promptly", () => {
+        const started = Date.now();
+        const result = matchesOperator(SUBJECT, "like", HOSTILE);
+        const elapsed = Date.now() - started;
+
+        expect(result).toBe(false);
+        expect(elapsed).toBeLessThan(1000);
+    });
+
+    it("answers the case-insensitive form promptly too", () => {
+        const started = Date.now();
+        matchesOperator(SUBJECT, "ilike", HOSTILE);
+
+        expect(Date.now() - started).toBeLessThan(1000);
+    });
+
+    it("still means what LIKE means", () => {
+        expect(matchesOperator("post-1", "like", "post-%")).toBe(true);
+        expect(matchesOperator("post-1", "like", "%1")).toBe(true);
+        expect(matchesOperator("post-1", "like", "%st-%")).toBe(true);
+        expect(matchesOperator("post-1", "like", "other-%")).toBe(false);
+        // A run of wildcards is the same query as one wildcard.
+        expect(matchesOperator("post-1", "like", "post%%%%1")).toBe(true);
+        expect(matchesOperator("abc", "like", "a_c")).toBe(true);
+        expect(matchesOperator("abbc", "like", "a_c")).toBe(false);
+        // `_` is fixed-width, so a run of them still counts.
+        expect(matchesOperator("abc", "like", "a__")).toBe(true);
+        expect(matchesOperator("ab", "like", "a__")).toBe(false);
+    });
+
+    it("keeps an escaped percent literal", () => {
+        expect(matchesOperator("50%", "like", "50\\%")).toBe(true);
+        expect(matchesOperator("500", "like", "50\\%")).toBe(false);
+        // An escaped percent next to a wildcard is still a literal.
+        expect(matchesOperator("50%off", "like", "50\\%%")).toBe(true);
+        expect(matchesOperator("50off", "like", "50\\%%")).toBe(false);
+    });
+});

package/src/offline-query.test.ts

@@ -10,7 +10,8 @@ import {
     runLocalQuery,
     sortRows
 } from "./offline-query";
-import { EntityRelation } from "@rebasepro/types";
+import { DEFAULT_LIST_LIMIT, EntityRelation } from "@rebasepro/types";
+import { resolveFindWindow } from "@rebasepro/common";
 import type { FindParams } from "./transport";
 
 type Row = Record<string, unknown>;
@@ -172,12 +173,37 @@ describe("local query engine", () => {
 
     describe("pagination", () => {
         it("resolves page over offset the way the server does", () => {
-            expect(resolvePagination()).toEqual({ limit: 20, offset: 0 });
             expect(resolvePagination({ limit: 10, offset: 30 })).toEqual({ limit: 10, offset: 30 });
             expect(resolvePagination({ limit: 10, page: 3 })).toEqual({ limit: 10, offset: 20 });
             // `page` wins over `offset`, and the first page is not negative.
             expect(resolvePagination({ limit: 10, page: 1, offset: 99 })).toEqual({ limit: 10, offset: 0 });
         });
+
+        it("defaults to the same page size the server would apply", () => {
+            // Asserted against the constant, not against a number written here.
+            // This test used to say `{ limit: 20 }` — restating a default this
+            // module had invented, while `/api/data` paged by 50. The local
+            // answer and the network answer to one `observe()` were therefore
+            // different lengths, and the test agreed with the wrong one.
+            expect(resolvePagination()).toEqual({ limit: DEFAULT_LIST_LIMIT, offset: 0 });
+        });
+
+        it("agrees with the shared resolver on every shape of window", () => {
+            // The one that matters: the local evaluator and every other
+            // transport must resolve identical windows, or a cached list and a
+            // fetched list disagree about which rows page two holds.
+            for (const params of [
+                undefined,
+                { limit: 10 },
+                { offset: 30 },
+                { page: 4 },
+                { limit: 25, page: 2 },
+                { limit: 10, page: 1, offset: 99 }
+            ]) {
+                const { limit, offset } = resolveFindWindow(params);
+                expect(resolvePagination(params)).toEqual({ limit, offset });
+            }
+        });
     });
 
     describe("runLocalQuery", () => {