@confect/react 10.0.0-next.9 → 10.0.0

package/dist/StreamPagination.d.ts

@@ -0,0 +1,159 @@
+/**
+ * EXPERIMENTAL—the pure state machine behind {@link useStreamPaginatedQuery}
+ * (see `notes/stream-based-querying.md` in the repo root).
+ *
+ * Reactive pagination without the query journal: every loaded page—including
+ * the first—is pinned to a fixed index range by echoing its `continueCursor`
+ * back as the next subscription's `endCursor` (the last page pins to the
+ * end-of-stream sentinel once exhausted), so adjacent pages stay exactly
+ * contiguous and pages never shed items as data changes—the "range-defined
+ * pages" the Fully Reactive Pagination article calls for, and the mechanism of
+ * `convex-helpers/react`'s `usePaginatedQuery`.
+ *
+ * Pinning a freshly loaded page, loading more, and splitting an overgrown page
+ * are the same transition shape: the affected page keeps rendering while its
+ * replacement subscriptions ("ongoing split") load, and is swapped out once all
+ * of them have results.
+ *
+ * This module is framework-free (it imports only `effect/*` and a type from
+ * `convex/server`); it lives here for now because the React hook is its only
+ * consumer—a second client (e.g. `@confect/foldkit`) should prompt a move down
+ * to `@confect/js`.
+ */
+import type { PaginationResult } from "convex/server";
+import * as Option from "effect/Option";
+import * as Record from "effect/Record";
+/**
+ * The `paginationOpts` one subscribed page queries with.
+ */
+export interface PageRequest {
+    readonly numItems: number;
+    readonly cursor: string | null;
+    /**
+     * Present once the page is pinned to a fixed range.
+     */
+    readonly endCursor?: string;
+    /**
+     * Per-page read budgets, forwarded to the server so a scan-heavy page fails
+     * over to `SplitRequired` instead of exceeding query limits.
+     */
+    readonly maximumRowsRead?: number;
+    readonly maximumBytesRead?: number;
+}
+/**
+ * The per-page read budgets every growing page is requested with.
+ */
+export interface ReadBudget {
+    readonly maximumRowsRead?: number | undefined;
+    readonly maximumBytesRead?: number | undefined;
+}
+export interface State {
+    readonly nextPageKey: number;
+    /**
+     * Page keys in display order.
+     */
+    readonly pageKeys: ReadonlyArray<string>;
+    /**
+     * The request each subscribed page queries with, by page key.
+     */
+    readonly pages: Record.ReadonlyRecord<string, PageRequest>;
+    /**
+     * Pages being replaced by one (a pin) or two (a split) narrower
+     * subscriptions: the original stays subscribed (and rendered) until every
+     * replacement has a result.
+     */
+    readonly ongoingSplits: Record.ReadonlyRecord<string, ReadonlyArray<string>>;
+}
+/**
+ * The skipped state: nothing subscribed.
+ */
+export declare const empty: State;
+/**
+ * One growing (unpinned) page from the start of the stream.
+ */
+export declare const initial: (initialNumItems: number, budget?: ReadBudget) => State;
+/**
+ * Pin a freshly loaded growing page at its `continueCursor` (or, once
+ * exhausted, at the end-of-stream sentinel), so it stops being a sliding
+ * window: a pinned page grows and shrinks with the data in its range but never
+ * sheds items past its edges. Modeled as a one-replacement split so the
+ * original keeps rendering until the pinned twin has a result.
+ */
+export declare const pin: (key: string, endCursor: string) => ((state: State) => State);
+/**
+ * Pin the growing last page at `continueCursor` and start a new growing page
+ * from there. Modeled as a split of the last page into its pinned replacement
+ * and the new page, so the swap waits for both.
+ */
+export declare const loadMore: (continueCursor: string, numItems: number, budget?: ReadBudget) => ((state: State) => State);
+/**
+ * Split the page at `key` in two at `splitCursor`. The first replacement pins
+ * at the split point; the second keeps the page's own `endCursor`—for a pinned
+ * page its original end (so a truncated `SplitRequired` page loses none of its
+ * range), and for a growing page no end at all (it keeps growing).
+ */
+export declare const split: (key: string, splitCursor: string) => ((state: State) => State);
+/**
+ * Swap a completed split's replacements in for the original page.
+ */
+export declare const completeSplit: (key: string) => ((state: State) => State);
+/**
+ * Whether the last (rendered) page is currently being split or pinned.
+ */
+export declare const isLastPageSplitting: (state: State) => boolean;
+/**
+ * Build one subscription request per subscribed page.
+ */
+export declare const pageRequests: <A>(state: State, f: (page: PageRequest) => A) => Record.ReadonlyRecord<string, A>;
+/**
+ * The per-page results a render observes, keyed like {@link pageRequests}.
+ */
+export type Results = Record.ReadonlyRecord<string, PageResult | Error | undefined>;
+/**
+ * The wire shape of one loaded page—`PaginationResult` from `convex/server`, so
+ * the protocol has a single source of truth.
+ */
+export type PageResult = PaginationResult<unknown>;
+/**
+ * What one render pass derives from the subscribed pages' results: the items to
+ * show, the trailing complete result (absent while the tail is loading or
+ * force-splitting), state transitions to apply, and whether a failure or an
+ * invalid cursor was hit.
+ */
+export type Interpretation = {
+    readonly _tag: "ResetRequired";
+} | {
+    readonly _tag: "Failed";
+    readonly error: unknown;
+    /**
+     * Encoded items loaded before the failing page.
+     */
+    readonly items: ReadonlyArray<unknown>;
+} | {
+    readonly _tag: "Interpreted";
+    /**
+     * Encoded items across the loaded pages, in order.
+     */
+    readonly items: ReadonlyArray<unknown>;
+    /**
+     * The last page's result, when every page has loaded completely.
+     */
+    readonly lastResult: Option.Option<PageResult>;
+    /**
+     * Split/swap transitions this render discovered.
+     */
+    readonly transitions: ReadonlyArray<(state: State) => State>;
+};
+/**
+ * Walk the pages in display order, concatenating their items and collecting the
+ * transitions to apply (completed split swaps, recommended splits, eager splits
+ * of pages that outgrew `initialNumItems`).
+ *
+ * `isInvalidCursorError` marks errors that call for a full pagination reset
+ * rather than a failure (the cursor no longer matches the query).
+ */
+export declare const interpret: (state: State, results: Record.ReadonlyRecord<string, PageResult | Error | undefined>, options: {
+    readonly initialNumItems: number;
+    readonly isInvalidCursorError: (error: Error) => boolean;
+}) => Interpretation;
+//# sourceMappingURL=StreamPagination.d.ts.map

package/dist/StreamPagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamPagination.d.ts","sourceRoot":"","sources":["../src/StreamPagination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChD;AAoBD,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC3D;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;CAC9E;AAED;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,KAKnB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,oBACD,MAAM,WACf,UAAU,KACjB,KAKD,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,QACR,MAAM,aAAa,MAAM,KAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAmBtD,CAAC;AAEP;;;;GAIG;AACH,eAAO,MAAM,QAAQ,mBAED,MAAM,YACZ,MAAM,WACR,UAAU,KACjB,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CA8CxB,CAAC;AAEN;;;;;GAKG;AACH,eAAO,MAAM,KAAK,QACV,MAAM,eAAe,MAAM,KAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAqBxD,CAAC;AAEP;;GAEG;AACH,eAAO,MAAM,aAAa,QAClB,MAAM,KAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAYnC,CAAC;AAEP;;GAEG;AACH,eAAO,MAAM,mBAAmB,UAAW,KAAK,KAAG,OAGhD,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SACrB,KAAK,KACT,CAAC,IAAI,EAAE,WAAW,KAAK,CAAC,KAC1B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,CAA+B,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,cAAc,CACzC,MAAM,EACN,UAAU,GAAG,KAAK,GAAG,SAAS,CAC/B,CAAC;AAMF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAClC;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACxC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACvC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAC/C;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAAC,CAAC;CAC9D,CAAC;AAQN;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,UACb,KAAK,WACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,KAAK,GAAG,SAAS,CAAC,WAC7D;IACP,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,oBAAoB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;CAC1D,KACA,cAmEF,CAAC"}

package/dist/StreamPagination.js

@@ -0,0 +1,182 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Option from "effect/Option";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Record from "effect/Record";
+//#region src/StreamPagination.ts
+var StreamPagination_exports = /* @__PURE__ */ __exportAll({
+	completeSplit: () => completeSplit,
+	empty: () => empty,
+	initial: () => initial,
+	interpret: () => interpret,
+	isLastPageSplitting: () => isLastPageSplitting,
+	loadMore: () => loadMore,
+	pageRequests: () => pageRequests,
+	pin: () => pin,
+	split: () => split
+});
+/**
+* A fresh growing-page request (no `endCursor`).
+*/
+const growingRequest = (numItems, cursor, budget) => ({
+	numItems,
+	cursor,
+	...budget.maximumRowsRead === void 0 ? {} : { maximumRowsRead: budget.maximumRowsRead },
+	...budget.maximumBytesRead === void 0 ? {} : { maximumBytesRead: budget.maximumBytesRead }
+});
+/**
+* The skipped state: nothing subscribed.
+*/
+const empty = {
+	nextPageKey: 0,
+	pageKeys: [],
+	pages: Record.empty(),
+	ongoingSplits: Record.empty()
+};
+/**
+* One growing (unpinned) page from the start of the stream.
+*/
+const initial = (initialNumItems, budget = {}) => ({
+	nextPageKey: 1,
+	pageKeys: ["0"],
+	pages: Record.singleton("0", growingRequest(initialNumItems, null, budget)),
+	ongoingSplits: Record.empty()
+});
+/**
+* Pin a freshly loaded growing page at its `continueCursor` (or, once
+* exhausted, at the end-of-stream sentinel), so it stops being a sliding
+* window: a pinned page grows and shrinks with the data in its range but never
+* sheds items past its edges. Modeled as a one-replacement split so the
+* original keeps rendering until the pinned twin has a result.
+*/
+const pin = (key, endCursor) => (state) => Option.match(Record.get(state.pages, key), {
+	onNone: () => state,
+	onSome: (page) => {
+		if (page.endCursor !== void 0 || Record.has(state.ongoingSplits, key)) return state;
+		const pinnedKey = String(state.nextPageKey);
+		return {
+			nextPageKey: state.nextPageKey + 1,
+			pageKeys: state.pageKeys,
+			pages: Record.set(state.pages, pinnedKey, {
+				...page,
+				endCursor
+			}),
+			ongoingSplits: Record.set(state.ongoingSplits, key, [pinnedKey])
+		};
+	}
+});
+/**
+* Pin the growing last page at `continueCursor` and start a new growing page
+* from there. Modeled as a split of the last page into its pinned replacement
+* and the new page, so the swap waits for both.
+*/
+const loadMore = (continueCursor, numItems, budget = {}) => (state) => pipe(Option.Do, Option.bind("lastKey", () => Array.last(state.pageKeys)), Option.bind("lastPage", ({ lastKey }) => Record.get(state.pages, lastKey)), Option.match({
+	onNone: () => state,
+	onSome: ({ lastKey, lastPage }) => {
+		if (lastPage.endCursor !== void 0) {
+			const nextKey = String(state.nextPageKey);
+			return {
+				nextPageKey: state.nextPageKey + 1,
+				pageKeys: Array.append(state.pageKeys, nextKey),
+				pages: Record.set(state.pages, nextKey, growingRequest(numItems, continueCursor, budget)),
+				ongoingSplits: state.ongoingSplits
+			};
+		}
+		const pinnedKey = String(state.nextPageKey);
+		const nextKey = String(state.nextPageKey + 1);
+		return {
+			nextPageKey: state.nextPageKey + 2,
+			pageKeys: state.pageKeys,
+			pages: pipe(state.pages, Record.set(pinnedKey, {
+				...lastPage,
+				endCursor: continueCursor
+			}), Record.set(nextKey, growingRequest(numItems, continueCursor, budget))),
+			ongoingSplits: Record.set(state.ongoingSplits, lastKey, [pinnedKey, nextKey])
+		};
+	}
+}));
+/**
+* Split the page at `key` in two at `splitCursor`. The first replacement pins
+* at the split point; the second keeps the page's own `endCursor`—for a pinned
+* page its original end (so a truncated `SplitRequired` page loses none of its
+* range), and for a growing page no end at all (it keeps growing).
+*/
+const split = (key, splitCursor) => (state) => Option.match(Record.get(state.pages, key), {
+	onNone: () => state,
+	onSome: (page) => {
+		const firstKey = String(state.nextPageKey);
+		const secondKey = String(state.nextPageKey + 1);
+		return {
+			nextPageKey: state.nextPageKey + 2,
+			pageKeys: state.pageKeys,
+			pages: pipe(state.pages, Record.set(firstKey, {
+				...page,
+				endCursor: splitCursor
+			}), Record.set(secondKey, {
+				...page,
+				cursor: splitCursor
+			})),
+			ongoingSplits: Record.set(state.ongoingSplits, key, [firstKey, secondKey])
+		};
+	}
+});
+/**
+* Swap a completed split's replacements in for the original page.
+*/
+const completeSplit = (key) => (state) => Option.match(Record.get(state.ongoingSplits, key), {
+	onNone: () => state,
+	onSome: (replacements) => ({
+		nextPageKey: state.nextPageKey,
+		pageKeys: Array.flatMap(state.pageKeys, (pageKey) => pageKey === key ? replacements : [pageKey]),
+		pages: Record.remove(state.pages, key),
+		ongoingSplits: Record.remove(state.ongoingSplits, key)
+	})
+});
+/**
+* Whether the last (rendered) page is currently being split or pinned.
+*/
+const isLastPageSplitting = (state) => Option.exists(Array.last(state.pageKeys), (lastKey) => Record.has(state.ongoingSplits, lastKey));
+/**
+* Build one subscription request per subscribed page.
+*/
+const pageRequests = (state, f) => Record.map(state.pages, f);
+const interpreted = (items, lastResult, transitions) => ({
+	_tag: "Interpreted",
+	items,
+	lastResult,
+	transitions
+});
+/**
+* Walk the pages in display order, concatenating their items and collecting the
+* transitions to apply (completed split swaps, recommended splits, eager splits
+* of pages that outgrew `initialNumItems`).
+*
+* `isInvalidCursorError` marks errors that call for a full pagination reset
+* rather than a failure (the cursor no longer matches the query).
+*/
+const interpret = (state, results, options) => {
+	const go = (remaining, items, transitions, lastResult) => Option.match(Array.head(remaining), {
+		onNone: () => interpreted(items, lastResult, transitions),
+		onSome: (pageKey) => {
+			const result = Record.get(results, pageKey).pipe(Option.flatMap(Option.fromNullishOr), Option.getOrUndefined);
+			if (result === void 0) return interpreted(items, Option.none(), transitions);
+			if (result instanceof Error) return options.isInvalidCursorError(result) ? { _tag: "ResetRequired" } : {
+				_tag: "Failed",
+				error: result,
+				items
+			};
+			const hasResult = (key) => Record.get(results, key).pipe(Option.flatMap(Option.fromNullishOr), Option.isSome);
+			const ongoingSplit = Record.get(state.ongoingSplits, pageKey);
+			const nextTransitions = Option.match(ongoingSplit, {
+				onSome: (replacements) => Array.every(replacements, hasResult) ? Array.append(transitions, completeSplit(pageKey)) : transitions,
+				onNone: () => typeof result.splitCursor === "string" && (result.pageStatus === "SplitRecommended" || result.pageStatus === "SplitRequired" || result.page.length > options.initialNumItems) ? Array.append(transitions, split(pageKey, result.splitCursor)) : Option.exists(Record.get(state.pages, pageKey), (request) => request.endCursor === void 0) && result.pageStatus !== "SplitRequired" ? Array.append(transitions, pin(pageKey, result.continueCursor)) : transitions
+			});
+			return result.pageStatus === "SplitRequired" ? interpreted(items, Option.none(), nextTransitions) : go(Array.drop(remaining, 1), Array.appendAll(items, result.page), nextTransitions, Option.some(result));
+		}
+	});
+	return go(state.pageKeys, [], [], Option.none());
+};
+//#endregion
+export { StreamPagination_exports, completeSplit, empty, initial, interpret, isLastPageSplitting, loadMore, pageRequests, pin, split };
+
+//# sourceMappingURL=StreamPagination.js.map

package/dist/StreamPagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamPagination.js","names":[],"sources":["../src/StreamPagination.ts"],"sourcesContent":["/**\n * EXPERIMENTAL—the pure state machine behind {@link useStreamPaginatedQuery}\n * (see `notes/stream-based-querying.md` in the repo root).\n *\n * Reactive pagination without the query journal: every loaded page—including\n * the first—is pinned to a fixed index range by echoing its `continueCursor`\n * back as the next subscription's `endCursor` (the last page pins to the\n * end-of-stream sentinel once exhausted), so adjacent pages stay exactly\n * contiguous and pages never shed items as data changes—the \"range-defined\n * pages\" the Fully Reactive Pagination article calls for, and the mechanism of\n * `convex-helpers/react`'s `usePaginatedQuery`.\n *\n * Pinning a freshly loaded page, loading more, and splitting an overgrown page\n * are the same transition shape: the affected page keeps rendering while its\n * replacement subscriptions (\"ongoing split\") load, and is swapped out once all\n * of them have results.\n *\n * This module is framework-free (it imports only `effect/*` and a type from\n * `convex/server`); it lives here for now because the React hook is its only\n * consumer—a second client (e.g. `@confect/foldkit`) should prompt a move down\n * to `@confect/js`.\n */\nimport type { PaginationResult } from \"convex/server\";\nimport * as Array from \"effect/Array\";\nimport * as Option from \"effect/Option\";\nimport { pipe } from \"effect/Function\";\nimport * as Record from \"effect/Record\";\n\n/**\n * The `paginationOpts` one subscribed page queries with.\n */\nexport interface PageRequest {\n  readonly numItems: number;\n  readonly cursor: string | null;\n  /**\n   * Present once the page is pinned to a fixed range.\n   */\n  readonly endCursor?: string;\n  /**\n   * Per-page read budgets, forwarded to the server so a scan-heavy page fails\n   * over to `SplitRequired` instead of exceeding query limits.\n   */\n  readonly maximumRowsRead?: number;\n  readonly maximumBytesRead?: number;\n}\n\n/**\n * The per-page read budgets every growing page is requested with.\n */\nexport interface ReadBudget {\n  readonly maximumRowsRead?: number | undefined;\n  readonly maximumBytesRead?: number | undefined;\n}\n\n/**\n * A fresh growing-page request (no `endCursor`).\n */\nconst growingRequest = (\n  numItems: number,\n  cursor: string | null,\n  budget: ReadBudget,\n): PageRequest => ({\n  numItems,\n  cursor,\n  ...(budget.maximumRowsRead === undefined\n    ? {}\n    : { maximumRowsRead: budget.maximumRowsRead }),\n  ...(budget.maximumBytesRead === undefined\n    ? {}\n    : { maximumBytesRead: budget.maximumBytesRead }),\n});\n\nexport interface State {\n  readonly nextPageKey: number;\n  /**\n   * Page keys in display order.\n   */\n  readonly pageKeys: ReadonlyArray<string>;\n  /**\n   * The request each subscribed page queries with, by page key.\n   */\n  readonly pages: Record.ReadonlyRecord<string, PageRequest>;\n  /**\n   * Pages being replaced by one (a pin) or two (a split) narrower\n   * subscriptions: the original stays subscribed (and rendered) until every\n   * replacement has a result.\n   */\n  readonly ongoingSplits: Record.ReadonlyRecord<string, ReadonlyArray<string>>;\n}\n\n/**\n * The skipped state: nothing subscribed.\n */\nexport const empty: State = {\n  nextPageKey: 0,\n  pageKeys: [],\n  pages: Record.empty(),\n  ongoingSplits: Record.empty(),\n};\n\n/**\n * One growing (unpinned) page from the start of the stream.\n */\nexport const initial = (\n  initialNumItems: number,\n  budget: ReadBudget = {},\n): State => ({\n  nextPageKey: 1,\n  pageKeys: [\"0\"],\n  pages: Record.singleton(\"0\", growingRequest(initialNumItems, null, budget)),\n  ongoingSplits: Record.empty(),\n});\n\n/**\n * Pin a freshly loaded growing page at its `continueCursor` (or, once\n * exhausted, at the end-of-stream sentinel), so it stops being a sliding\n * window: a pinned page grows and shrinks with the data in its range but never\n * sheds items past its edges. Modeled as a one-replacement split so the\n * original keeps rendering until the pinned twin has a result.\n */\nexport const pin =\n  (key: string, endCursor: string): ((state: State) => State) =>\n  (state) =>\n    Option.match(Record.get(state.pages, key), {\n      onNone: () => state,\n      onSome: (page) => {\n        if (\n          page.endCursor !== undefined ||\n          Record.has(state.ongoingSplits, key)\n        ) {\n          return state;\n        }\n        const pinnedKey = String(state.nextPageKey);\n        return {\n          nextPageKey: state.nextPageKey + 1,\n          pageKeys: state.pageKeys,\n          pages: Record.set(state.pages, pinnedKey, { ...page, endCursor }),\n          ongoingSplits: Record.set(state.ongoingSplits, key, [pinnedKey]),\n        };\n      },\n    });\n\n/**\n * Pin the growing last page at `continueCursor` and start a new growing page\n * from there. Modeled as a split of the last page into its pinned replacement\n * and the new page, so the swap waits for both.\n */\nexport const loadMore =\n  (\n    continueCursor: string,\n    numItems: number,\n    budget: ReadBudget = {},\n  ): ((state: State) => State) =>\n  (state) =>\n    pipe(\n      Option.Do,\n      Option.bind(\"lastKey\", () => Array.last(state.pageKeys)),\n      Option.bind(\"lastPage\", ({ lastKey }) =>\n        Record.get(state.pages, lastKey),\n      ),\n      Option.match({\n        onNone: () => state,\n        onSome: ({ lastKey, lastPage }) => {\n          if (lastPage.endCursor !== undefined) {\n            // The last page is already pinned (the usual case, since pages\n            // pin themselves on first load): just append a new growing page.\n            const nextKey = String(state.nextPageKey);\n            return {\n              nextPageKey: state.nextPageKey + 1,\n              pageKeys: Array.append(state.pageKeys, nextKey),\n              pages: Record.set(\n                state.pages,\n                nextKey,\n                growingRequest(numItems, continueCursor, budget),\n              ),\n              ongoingSplits: state.ongoingSplits,\n            };\n          }\n          const pinnedKey = String(state.nextPageKey);\n          const nextKey = String(state.nextPageKey + 1);\n          return {\n            nextPageKey: state.nextPageKey + 2,\n            pageKeys: state.pageKeys,\n            pages: pipe(\n              state.pages,\n              Record.set(pinnedKey, { ...lastPage, endCursor: continueCursor }),\n              Record.set(\n                nextKey,\n                growingRequest(numItems, continueCursor, budget),\n              ),\n            ),\n            ongoingSplits: Record.set(state.ongoingSplits, lastKey, [\n              pinnedKey,\n              nextKey,\n            ]),\n          };\n        },\n      }),\n    );\n\n/**\n * Split the page at `key` in two at `splitCursor`. The first replacement pins\n * at the split point; the second keeps the page's own `endCursor`—for a pinned\n * page its original end (so a truncated `SplitRequired` page loses none of its\n * range), and for a growing page no end at all (it keeps growing).\n */\nexport const split =\n  (key: string, splitCursor: string): ((state: State) => State) =>\n  (state) =>\n    Option.match(Record.get(state.pages, key), {\n      onNone: () => state,\n      onSome: (page) => {\n        const firstKey = String(state.nextPageKey);\n        const secondKey = String(state.nextPageKey + 1);\n        return {\n          nextPageKey: state.nextPageKey + 2,\n          pageKeys: state.pageKeys,\n          pages: pipe(\n            state.pages,\n            Record.set(firstKey, { ...page, endCursor: splitCursor }),\n            Record.set(secondKey, { ...page, cursor: splitCursor }),\n          ),\n          ongoingSplits: Record.set(state.ongoingSplits, key, [\n            firstKey,\n            secondKey,\n          ]),\n        };\n      },\n    });\n\n/**\n * Swap a completed split's replacements in for the original page.\n */\nexport const completeSplit =\n  (key: string): ((state: State) => State) =>\n  (state) =>\n    Option.match(Record.get(state.ongoingSplits, key), {\n      onNone: () => state,\n      onSome: (replacements) => ({\n        nextPageKey: state.nextPageKey,\n        pageKeys: Array.flatMap(state.pageKeys, (pageKey) =>\n          pageKey === key ? replacements : [pageKey],\n        ),\n        pages: Record.remove(state.pages, key),\n        ongoingSplits: Record.remove(state.ongoingSplits, key),\n      }),\n    });\n\n/**\n * Whether the last (rendered) page is currently being split or pinned.\n */\nexport const isLastPageSplitting = (state: State): boolean =>\n  Option.exists(Array.last(state.pageKeys), (lastKey) =>\n    Record.has(state.ongoingSplits, lastKey),\n  );\n\n/**\n * Build one subscription request per subscribed page.\n */\nexport const pageRequests = <A>(\n  state: State,\n  f: (page: PageRequest) => A,\n): Record.ReadonlyRecord<string, A> => Record.map(state.pages, f);\n\n/**\n * The per-page results a render observes, keyed like {@link pageRequests}.\n */\nexport type Results = Record.ReadonlyRecord<\n  string,\n  PageResult | Error | undefined\n>;\n\n// -----------------------------------------------------------------------------\n// Interpretation\n// -----------------------------------------------------------------------------\n\n/**\n * The wire shape of one loaded page—`PaginationResult` from `convex/server`, so\n * the protocol has a single source of truth.\n */\nexport type PageResult = PaginationResult<unknown>;\n\n/**\n * What one render pass derives from the subscribed pages' results: the items to\n * show, the trailing complete result (absent while the tail is loading or\n * force-splitting), state transitions to apply, and whether a failure or an\n * invalid cursor was hit.\n */\nexport type Interpretation =\n  | { readonly _tag: \"ResetRequired\" }\n  | {\n      readonly _tag: \"Failed\";\n      readonly error: unknown;\n      /**\n       * Encoded items loaded before the failing page.\n       */\n      readonly items: ReadonlyArray<unknown>;\n    }\n  | {\n      readonly _tag: \"Interpreted\";\n      /**\n       * Encoded items across the loaded pages, in order.\n       */\n      readonly items: ReadonlyArray<unknown>;\n      /**\n       * The last page's result, when every page has loaded completely.\n       */\n      readonly lastResult: Option.Option<PageResult>;\n      /**\n       * Split/swap transitions this render discovered.\n       */\n      readonly transitions: ReadonlyArray<(state: State) => State>;\n    };\n\nconst interpreted = (\n  items: ReadonlyArray<unknown>,\n  lastResult: Option.Option<PageResult>,\n  transitions: ReadonlyArray<(state: State) => State>,\n): Interpretation => ({ _tag: \"Interpreted\", items, lastResult, transitions });\n\n/**\n * Walk the pages in display order, concatenating their items and collecting the\n * transitions to apply (completed split swaps, recommended splits, eager splits\n * of pages that outgrew `initialNumItems`).\n *\n * `isInvalidCursorError` marks errors that call for a full pagination reset\n * rather than a failure (the cursor no longer matches the query).\n */\nexport const interpret = (\n  state: State,\n  results: Record.ReadonlyRecord<string, PageResult | Error | undefined>,\n  options: {\n    readonly initialNumItems: number;\n    readonly isInvalidCursorError: (error: Error) => boolean;\n  },\n): Interpretation => {\n  const go = (\n    remaining: ReadonlyArray<string>,\n    items: ReadonlyArray<unknown>,\n    transitions: ReadonlyArray<(s: State) => State>,\n    lastResult: Option.Option<PageResult>,\n  ): Interpretation =>\n    Option.match(Array.head(remaining), {\n      onNone: () => interpreted(items, lastResult, transitions),\n      onSome: (pageKey) => {\n        const result = Record.get(results, pageKey).pipe(\n          Option.flatMap(Option.fromNullishOr),\n          Option.getOrUndefined,\n        );\n        if (result === undefined) {\n          // The trailing pages are still loading.\n          return interpreted(items, Option.none(), transitions);\n        }\n        if (result instanceof Error) {\n          return options.isInvalidCursorError(result)\n            ? { _tag: \"ResetRequired\" }\n            : { _tag: \"Failed\", error: result, items };\n        }\n\n        const hasResult = (key: string) =>\n          Record.get(results, key).pipe(\n            Option.flatMap(Option.fromNullishOr),\n            Option.isSome,\n          );\n        const ongoingSplit = Record.get(state.ongoingSplits, pageKey);\n        const nextTransitions = Option.match(ongoingSplit, {\n          onSome: (replacements) =>\n            // Swap the replacements in once all of them have results.\n            Array.every(replacements, hasResult)\n              ? Array.append(transitions, completeSplit(pageKey))\n              : transitions,\n          onNone: () =>\n            typeof result.splitCursor === \"string\" &&\n            (result.pageStatus === \"SplitRecommended\" ||\n              result.pageStatus === \"SplitRequired\" ||\n              result.page.length > options.initialNumItems)\n              ? Array.append(transitions, split(pageKey, result.splitCursor))\n              : // A loaded growing page pins itself to the range it just\n                // served (`END_CURSOR` once exhausted), so it stops being a\n                // sliding window that sheds items as new documents arrive.\n                Option.exists(\n                    Record.get(state.pages, pageKey),\n                    (request) => request.endCursor === undefined,\n                  ) && result.pageStatus !== \"SplitRequired\"\n                ? Array.append(transitions, pin(pageKey, result.continueCursor))\n                : transitions,\n        });\n\n        // A force-split page couldn't be fetched in full: show the items\n        // before it and report the tail as still loading.\n        return result.pageStatus === \"SplitRequired\"\n          ? interpreted(items, Option.none(), nextTransitions)\n          : go(\n              Array.drop(remaining, 1),\n              Array.appendAll(items, result.page),\n              nextTransitions,\n              Option.some(result),\n            );\n      },\n    });\n\n  return go(state.pageKeys, [], [], Option.none());\n};\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,13 +1,88 @@
 import { Ref } from "@confect/core";
+import type { usePaginatedQuery as useConvexPaginatedQuery } from "convex/react";
 import * as Result from "effect/Result";
 import * as OptimisticLocalStore from "./OptimisticLocalStore";
+import * as PaginatedQueryResult from "./PaginatedQueryResult";
 import * as QueryResult from "./QueryResult";
-export { OptimisticLocalStore, QueryResult };
+import * as StreamPagination from "./StreamPagination";
+export { OptimisticLocalStore, PaginatedQueryResult, QueryResult, StreamPagination, };
 export type InvokeReturn<Ref_ extends Ref.Any> = [Ref.Error<Ref_>] extends [
     never
 ] ? Promise<Ref.Returns<Ref_>> : Promise<Result.Result<Ref.Returns<Ref_>, Ref.Error<Ref_>>>;
 type UseQueryArgs<Query extends Ref.AnyPublicQuery> = keyof Ref.Args<Query> extends never ? [args?: Ref.Args<Query> | "skip"] : [args: Ref.Args<Query> | "skip"];
 export declare const useQuery: <Query extends Ref.AnyPublicQuery>(ref: Query, ...rest: UseQueryArgs<Query>) => QueryResult.QueryResult<Ref.Returns<Query>, Ref.Error<Query>>;
+/**
+ * Like `Omit`, but implemented with key remapping so that optional modifiers
+ * are preserved and index signatures don't reintroduce the omitted key's
+ * literal type. Mirrors `BetterOmit` from `convex/server`.
+ */
+type OmitKey<T, K extends PropertyKey> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+};
+/**
+ * The args accepted by {@link usePaginatedQuery}: the ref's args without
+ * `paginationOpts`, which the underlying Convex hook manages itself. When no
+ * args remain, resolves to `Record<string, never>` (only the empty object is
+ * accepted) rather than `{}`, which would accept any non-nullish value.
+ */
+export type PaginatedQueryArgs<Query extends Ref.AnyPublicPaginatedQuery> = OmitKey<Ref.Args<Query>, "paginationOpts"> extends infer Args_ ? keyof Args_ extends never ? Record<string, never> : Args_ : never;
+/**
+ * The item type for a paginated query: the element type of the `page` field of
+ * the ref's returns.
+ */
+export type PaginatedQueryItem<Query extends Ref.AnyPublicPaginatedQuery> = Ref.Returns<Query>["page"][number];
+/**
+ * The args parameter of {@link usePaginatedQuery}: the ref's args without
+ * `paginationOpts`, or `"skip"` to skip the query.
+ */
+export type UsePaginatedQueryArgs<Query extends Ref.AnyPublicPaginatedQuery> = PaginatedQueryArgs<Query> | "skip";
+export type PaginatedQueryOptions = Parameters<typeof useConvexPaginatedQuery>[2];
+/**
+ * Load data reactively from a paginated query defined with
+ * `FunctionSpec.publicPaginatedQuery`, mirroring the ergonomics of
+ * `usePaginatedQuery` from `convex/react`.
+ *
+ * Args are encoded via the ref's user-args schema (`paginationOpts` is managed
+ * by the Convex hook, not the caller), and each loaded page is decoded via the
+ * ref's item schema.
+ *
+ * Returns a {@link PaginatedQueryResult.PaginatedQueryResult}: the loaded
+ * variants carry `results` and `isLoading`, and `CanLoadMore` additionally
+ * carries `loadMore`; if the `Ref` declares an `error` schema and the query
+ * fails with that typed error, the decoded error is returned as the `Failure`
+ * variant, which also carries the pages loaded before the failure. Unknown
+ * errors are thrown, to be caught by an error boundary.
+ */
+export declare const usePaginatedQuery: <Query extends Ref.AnyPublicPaginatedQuery>(ref: Query, args: UsePaginatedQueryArgs<Query>, options: PaginatedQueryOptions) => PaginatedQueryResult.PaginatedQueryResult<PaginatedQueryItem<Query>, Ref.Error<Query>>;
+/**
+ * EXPERIMENTAL—endCursor-pinned reactive pagination (see
+ * `notes/stream-based-querying.md`). Use it with paginated queries whose
+ * handlers paginate via `QueryStream.paginate`: those don't write the query
+ * journal that {@link usePaginatedQuery}'s built-in reactivity relies on, so
+ * gap-free pages must be maintained by the client instead. (It works with any
+ * paginated query honoring the `endCursor` protocol field, including the
+ * built-in `paginate`.)
+ *
+ * Each loaded page is pinned to a fixed index range by re-subscribing it with
+ * its `continueCursor` echoed back as `endCursor`—pages then grow and shrink
+ * reactively but always meet exactly, and a page that outgrows
+ * `initialNumItems` is split in two. This is the mechanism of
+ * `convex-helpers/react`'s `usePaginatedQuery`, re-expressed over the pure
+ * {@link StreamPagination} state machine, with args/items/errors codec'd through
+ * the ref's schemas exactly like {@link usePaginatedQuery}.
+ */
+export declare const useStreamPaginatedQuery: <Query extends Ref.AnyPublicPaginatedQuery>(ref: Query, args: UsePaginatedQueryArgs<Query>, options: {
+    readonly initialNumItems: number;
+    /**
+     * Per-page read budgets forwarded as `paginationOpts.maximumRowsRead` and
+     * `paginationOpts.maximumBytesRead`: a page that would scan more rows, or
+     * read more bytes, than these returns truncated with `SplitRequired` (and
+     * the hook splits it) instead of exceeding Convex's query limits on a
+     * filter-heavy stream.
+     */
+    readonly maximumRowsRead?: number;
+    readonly maximumBytesRead?: number;
+}) => PaginatedQueryResult.PaginatedQueryResult<PaginatedQueryItem<Query>, Ref.Error<Query>>;
 /**
  * An optimistic update for a Confect mutation. Mirrors Convex's
  * `OptimisticUpdate`, but receives a Confect {@link OptimisticLocalStore} and

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAYpC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,KAAK,oBAAoB,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,WAAW,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAC;AAE7C,MAAM,MAAM,YAAY,CAAC,IAAI,SAAS,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,SAAS;IACzE,KAAK;CACN,GACG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAC1B,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAE/D,KAAK,YAAY,CAAC,KAAK,SAAS,GAAG,CAAC,cAAc,IAChD,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,GAC/B,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,GACjC,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC;AAEvC,eAAO,MAAM,QAAQ,GAAI,KAAK,SAAS,GAAG,CAAC,cAAc,EACvD,KAAK,KAAK,EACV,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,KAC3B,WAAW,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CA4C9D,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,QAAQ,SAAS,GAAG,CAAC,iBAAiB,IAAI,CACrE,UAAU,EAAE,oBAAoB,CAAC,oBAAoB,EACrD,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KACrB,IAAI,CAAC;AAEV;;;;;GAKG;AACH,MAAM,WAAW,aAAa,CAAC,QAAQ,SAAS,GAAG,CAAC,iBAAiB;IACnE,CAAC,GAAG,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC9D,oBAAoB,CAClB,gBAAgB,EAAE,gBAAgB,CAAC,QAAQ,CAAC,GAC3C,aAAa,CAAC,QAAQ,CAAC,CAAC;CAC5B;AAsCD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,SAAS,GAAG,CAAC,iBAAiB,EAChE,KAAK,QAAQ,KACZ,aAAa,CAAC,QAAQ,CAcxB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,SAAS,GAAG,CAAC,eAAe,EAC1D,KAAK,MAAM,KACV,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,YAAY,CAAC,MAAM,CAAC,CAe9D,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}