kitcn 0.32.2 → 0.33.1

package/dist/{schema-Bh7AmJwY.js → schema-BF4P0ZjS.js}

@@ -1313,6 +1313,327 @@ const ensureAggregateAllowedForRls = (tableConfig, rlsMode, methodName) => {
 	assertAggregateAllowedForRls(tableConfig, rlsMode, AGGREGATE_ERROR.RLS_UNSUPPORTED, methodName);
 };
 
+//#endregion
+//#region src/orm/transaction-cache.ts
+/**
+* Per-transaction memo storage for the ORM.
+*
+* The ORM already has isolate-, execution-, statement- and row-scoped memos.
+* A hook needs transaction lifetime: the write barrier is built inside
+* `createOrmDbLifecycle`, which `createOrm` runs at module scope,
+* so a flag in that closure lives as long as the isolate and would leak an
+* answer from one transaction into the next.
+*
+* Deliberately dependency-free, for the same reason as `write-fanout`:
+* `aggregate-index/runtime` is contractually unreachable from `orm/index`
+* (`import-graph.test.ts`), so importing `lifecycle` here to read one symbol
+* would drag the trigger runtime into the aggregate entry's bundle.
+* `Symbol.for` is registry-based, so re-declaring the key resolves to the same
+* symbol `lifecycle` installs.
+*/
+const ORMLIFECYCLE_INNER_DB = Symbol.for("kitcn:OrmLifecycleInnerDB");
+const ORM_TRANSACTION_ANCHOR = Symbol.for("kitcn:OrmTransactionAnchor");
+/**
+* Pins `anchor`'s transaction onto `target`, for a db built from a writer that
+* cannot be resolved back to it.
+*
+* `withoutTriggers` re-roots the ORM on the raw `ctx.db`, which is the one
+* object in the chain that carries no inner-db symbol — so a db derived from it
+* would otherwise stand for a transaction of its own and miss every memo and
+* queued write filed under the real one.
+*/
+const markOrmTransactionAnchor = (target, db) => {
+	const anchor = resolveOrmTransactionAnchor(db);
+	if (!anchor || Object.hasOwn(target, ORM_TRANSACTION_ANCHOR)) return target;
+	Object.defineProperty(target, ORM_TRANSACTION_ANCHOR, {
+		configurable: false,
+		enumerable: false,
+		value: anchor,
+		writable: false
+	});
+	return target;
+};
+/**
+* The object whose identity stands in for "this transaction".
+*
+* Convex builds `ctx.db` fresh on every UDF invocation, so it can never be
+* shared by two transactions. `getOrmLifecycleInnerDb` cannot be used on its
+* own: the lifecycle refuses to wrap readers and returns a no-op wrapper for
+* schemas with no triggers and no aggregate indexes, so the inner-db symbol is
+* absent for every query and for most mutations.
+*
+* Following the symbol to a fixed point, rather than one hop, is what makes the
+* answer canonical: `orm.with(hookCtx)` wraps a writer that is already a hook
+* wrapper, so one hop lands on the intermediate wrapper instead of the raw
+* writer the outer scope filed its work under. A pinned anchor wins outright,
+* because it is the only way a db rooted on the raw writer can name the
+* transaction at all.
+*
+* A nested `ctx.runMutation` shares the transaction but gets its own writer
+* and JS context. It cannot see caller-local memos or queued writes, nor can it
+* invalidate caller snapshots. Callers must flush deferred writes and expire
+* row snapshots before handing control to arbitrary user code.
+*/
+const resolveOrmTransactionAnchor = (db) => {
+	if (typeof db !== "object" || db === null) return;
+	let current = db;
+	const seen = new Set([current]);
+	for (;;) {
+		const pinned = current[ORM_TRANSACTION_ANCHOR];
+		if (typeof pinned === "object" && pinned !== null) return pinned;
+		const inner = current[ORMLIFECYCLE_INNER_DB];
+		if (typeof inner !== "object" || inner === null || seen.has(inner)) return current;
+		seen.add(inner);
+		current = inner;
+	}
+};
+/**
+* One memo namespace with transaction lifetime.
+*
+* The store is a `WeakMap` keyed on the anchor rather than a slot on the db,
+* because `createDatabase` promises not to mutate the `ctx.db` it was handed.
+* Entries die with the transaction's db object.
+*
+* Callers own staleness: only memoize a fact that nothing inside the
+* transaction can invalidate.
+*/
+const createOrmTransactionMemo = () => {
+	const byTransaction = /* @__PURE__ */ new WeakMap();
+	return {
+		get(db, key) {
+			const anchor = resolveOrmTransactionAnchor(db);
+			return anchor ? byTransaction.get(anchor)?.get(key) : void 0;
+		},
+		set(db, key, value) {
+			const anchor = resolveOrmTransactionAnchor(db);
+			if (!anchor) return;
+			const existing = byTransaction.get(anchor);
+			if (existing) {
+				existing.set(key, value);
+				return;
+			}
+			byTransaction.set(anchor, new Map([[key, value]]));
+		}
+	};
+};
+
+//#endregion
+//#region src/orm/write-cache.ts
+const scopes = createOrmTransactionMemo();
+const activeScopes = /* @__PURE__ */ new Set();
+let suspended$1 = 0;
+/** Snapshots may survive ORM-owned work, never a return to arbitrary code. */
+const runInOrmWriteScope = async (db, fn) => {
+	let scope = scopes.get(db, "write");
+	if (!scope) {
+		scope = {
+			depth: 0,
+			entries: /* @__PURE__ */ new Map()
+		};
+		scopes.set(db, "write", scope);
+	}
+	scope.entries.clear();
+	scope.depth += 1;
+	activeScopes.add(scope);
+	try {
+		return await fn();
+	} finally {
+		scope.entries.clear();
+		scope.depth -= 1;
+		if (scope.depth === 0) activeScopes.delete(scope);
+	}
+};
+/**
+* User code can call a nested UDF whose isolated JS context cannot invalidate
+* our snapshots. Suspend every active scope, including reentrant statements,
+* until the callback settles; never restore pre-callback entries.
+*/
+const withoutOrmWriteCache = async (fn) => {
+	for (const scope of activeScopes) scope.entries.clear();
+	suspended$1 += 1;
+	try {
+		return await fn();
+	} finally {
+		suspended$1 -= 1;
+	}
+};
+const createOrmWriteMemo = () => {
+	const namespace = Symbol("orm-write-memo");
+	return {
+		get(db, key) {
+			const scope = scopes.get(db, "write");
+			return !suspended$1 && scope?.depth ? scope.entries.get(namespace)?.get(key) : void 0;
+		},
+		set(db, key, value) {
+			const scope = scopes.get(db, "write");
+			if (suspended$1 || !scope?.depth) return;
+			let entries = scope.entries.get(namespace);
+			if (!entries) {
+				entries = /* @__PURE__ */ new Map();
+				scope.entries.set(namespace, entries);
+			}
+			entries.set(key, value);
+		}
+	};
+};
+
+//#endregion
+//#region src/orm/write-batch.ts
+/**
+* Statement-scoped deferral for the ORM write path.
+*
+* The lifecycle fires its hooks once per written document, so a subsystem that
+* maintains derived storage — aggregate index buckets, today — reconciles one
+* document at a time and rewrites the same storage document once per row. The
+* fold that would collapse those writes exists; what it lacks is a boundary
+* wide enough to fold across. A mutation statement is that boundary: one
+* `update()` / `delete()` / `insert()` is one unit of work whose derived writes
+* nobody can observe half-applied unless they read them, and a reader can be
+* made to drain first.
+*
+* Depends only on the anchor and row-cache lifetime, for the same reason as
+* `write-fanout`: the mutation builders are reachable from `orm/index`, the
+* aggregate runtime contractually is not (`import-graph.test.ts`), and both
+* ends have to name this module.
+*
+* Three invariants make it safe:
+*
+* 1. Every queued write is applied by `flushOrmWriteBatch` and nowhere else.
+*    Deltas are commutative but the writes that apply them are absolute
+*    read-modify-writes, so two of them interleaving is a lost update. Callers
+*    that have no batch open still enqueue and flush immediately rather than
+*    writing around the queue, which makes the drain the single writer and
+*    therefore the serialization point — the role `lifecycle`'s write lock
+*    plays for the documents it wraps.
+* 2. Aggregate readers and user callbacks drain first. Callback execution
+*    suspends deferral because nested UDFs cannot access the caller's queue.
+* 3. A flush callback must never itself drain. It runs inside the drain, and a
+*    drain in progress is awaited rather than skipped, so re-entering it would
+*    deadlock instead of returning stale rows. Keep the read barrier on the
+*    query-path entry points, which no flush callback calls.
+*/
+const batches = /* @__PURE__ */ new WeakMap();
+const activeBatches = /* @__PURE__ */ new Set();
+let suspended = 0;
+const getState = (db) => {
+	const anchor = resolveOrmTransactionAnchor(db);
+	if (!anchor) return;
+	const existing = batches.get(anchor);
+	if (existing) return existing;
+	const created = {
+		depth: 0,
+		flushers: /* @__PURE__ */ new Set(),
+		draining: null
+	};
+	batches.set(anchor, created);
+	return created;
+};
+/**
+* Runs every queued flush callback until none is left.
+*
+* A callback is removed before it runs, so work enqueued while the drain is in
+* flight is picked up by this same loop instead of being dropped or applied
+* twice. `draining` is published before the first callback and cleared in the
+* same synchronous step as the emptiness check that ends the loop, so a
+* caller either sees a drain it can wait for or starts its own — never a
+* window where its work is queued against a drain that has already left.
+*/
+const drain = (state) => {
+	if (state.draining) return state.draining;
+	let settled = false;
+	const running = (async () => {
+		try {
+			for (;;) {
+				const next = state.flushers.values().next();
+				if (next.done) return;
+				state.flushers.delete(next.value);
+				await next.value();
+			}
+		} finally {
+			state.draining = null;
+			settled = true;
+		}
+	})();
+	if (!settled) state.draining = running;
+	return running;
+};
+/**
+* Opens a write batch for the duration of `fn`.
+*
+* Nesting is reference-counted: a cascade that runs another statement inside
+* this one folds into the same batch rather than flushing the outer statement's
+* pending work early. The flush runs whether or not `fn` threw, so rows that
+* landed before a mid-statement throw still get their derived writes.
+*
+* When both throw, `fn`'s error wins and the flush failure rides along as its
+* `cause`. A plain `finally { await drain() }` would report the consequence and
+* swallow the reason — the statement's own failure is what a caller can act on.
+*/
+const runInOrmWriteBatch = async (db, fn) => {
+	const state = getState(db);
+	if (!state) return await fn();
+	state.depth += 1;
+	activeBatches.add(state);
+	let failure;
+	let result;
+	try {
+		result = await fn();
+	} catch (error) {
+		failure = { error };
+	}
+	state.depth -= 1;
+	if (state.depth > 0) {
+		if (failure) throw failure.error;
+		return result;
+	}
+	try {
+		await drain(state);
+	} catch (flushError) {
+		if (!failure) throw flushError;
+		if (failure.error instanceof Error && failure.error.cause === void 0) failure.error.cause = flushError;
+	} finally {
+		if (state.depth === 0) activeBatches.delete(state);
+	}
+	if (failure) throw failure.error;
+	return result;
+};
+/**
+* Queues `flush` for the next drain.
+*
+* Returns `false` only when `db` has no resolvable transaction, which is the
+* caller's signal that this module cannot help and the work has to be done
+* inline.
+*/
+const enqueueOrmWriteBatch = (db, flush) => {
+	const state = getState(db);
+	if (!state) return false;
+	state.flushers.add(flush);
+	return true;
+};
+/** True while a statement scope is holding the queue back. */
+const isOrmWriteBatchOpen = (db) => suspended === 0 && (getState(db)?.depth ?? 0) > 0;
+/** Nested UDFs cannot read or drain queues in the caller's JS context. */
+const runInOrmUserCallback = async (fn) => await withoutOrmWriteCache(async () => {
+	suspended += 1;
+	try {
+		for (const state of activeBatches) await drain(state);
+		return await fn();
+	} finally {
+		suspended -= 1;
+	}
+});
+/**
+* Applies everything queued. Both the read barrier and the only writer.
+*
+* Callers must be outside any flush callback; see this module's header.
+*/
+const flushOrmWriteBatch = async (db) => {
+	const anchor = resolveOrmTransactionAnchor(db);
+	const state = anchor ? batches.get(anchor) : void 0;
+	if (!state || !state.draining && state.flushers.size === 0) return;
+	await drain(state);
+};
+
 //#endregion
 //#region src/orm/aggregate-index/definitions.ts
 const getAggregateIndexDefinitions = (tableConfig) => {
@@ -1426,4 +1747,4 @@ function aggregateExtension() {
 }
 
 //#endregion
-export { patchReferencingRows as $, enforcePolymorphicWrite as A, getForeignKeys as B, collectPrimaryIdLookupRows as C, encodeUndefinedDeep as D, deserializeFilterExpression as E, evaluateCheckConstraintTriState as F, getTableColumns as G, getMutationCollectionLimits as H, evaluateFilter as I, getUniqueIndexes as J, getTableDeleteConfig as K, extractPrimaryIdLookup as L, ensureDefaultColumns as M, ensureNonNullValues as N, enforceCheckConstraints as O, ensureNullableColumns as P, normalizeTemporalComparableValue as Q, getChecks as R, collectMutationRowsBounded as S, decodeUndefinedDeep as T, getMutationExecutionMode as U, getMutationAsyncDelayMs as V, getOrmContext as W, hydrateDateFieldsForRead as X, hardDeleteRow as Y, normalizeDateFieldsForWrite as Z, applyDefaults as _, AGGREGATE_STATE_TABLE as a, splitReturningSelection as at, buildForeignKeyGraph as b, getAggregateIndexDefinitions as c, toConvexFilter as ct, COUNT_ERROR as d, markLifecycleHookedTables as dt, resolveOrmRuntimeDefaults as et, createAggregateError as f, compileConvexFilter as ft, ensureCountAllowedForRls as g, ensureAggregateAllowedForRls as h, mapWithConcurrency as ht, AGGREGATE_RANK_TREE_TABLE as i, softDeleteRow as it, enforceUniqueIndexes as j, enforceForeignKeys as k, getRankIndexDefinitions as l, unsetFieldsOf as lt, createError as m, isConvexEnforceableFilter as mt, AGGREGATE_EXTREMA_TABLE as n, selectReturningRowWithHydration as nt, aggregateExtension as o, stripUnsetFields as ot, createCountError as p, convexAnd as pt, getTableName as q, AGGREGATE_MEMBER_TABLE as r, serializeFilterExpression as rt, rankAggregateName as s, takeRowsWithinByteBudget as st, AGGREGATE_BUCKET_TABLE as t, returningSelectionReadsCreationTime as tt, AGGREGATE_ERROR as u, hasLifecycleHooks as ut, applyIncomingForeignKeyActionsOnDelete as v, createForeignKeyProbeMemo as w, canUsePrimaryIdLookupCursor as x, applyIncomingForeignKeyActionsOnUpdate as y, getColumnName as z };
+export { getOrmContext as $, canUsePrimaryIdLookupCursor as A, enforceUniqueIndexes as B, createError as C, isConvexEnforceableFilter as Ct, applyIncomingForeignKeyActionsOnDelete as D, applyDefaults as E, deserializeFilterExpression as F, evaluateFilter as G, ensureNonNullValues as H, encodeUndefinedDeep as I, getColumnName as J, extractPrimaryIdLookup as K, enforceCheckConstraints as L, collectPrimaryIdLookupRows as M, createForeignKeyProbeMemo as N, applyIncomingForeignKeyActionsOnUpdate as O, decodeUndefinedDeep as P, getMutationExecutionMode as Q, enforceForeignKeys as R, createCountError as S, convexAnd as St, ensureCountAllowedForRls as T, ensureNullableColumns as U, ensureDefaultColumns as V, evaluateCheckConstraintTriState as W, getMutationAsyncDelayMs as X, getForeignKeys as Y, getMutationCollectionLimits as Z, createOrmTransactionMemo as _, toConvexFilter as _t, AGGREGATE_STATE_TABLE as a, hydrateDateFieldsForRead as at, COUNT_ERROR as b, markLifecycleHookedTables as bt, getAggregateIndexDefinitions as c, patchReferencingRows as ct, flushOrmWriteBatch as d, selectReturningRowWithHydration as dt, getTableColumns as et, isOrmWriteBatchOpen as f, serializeFilterExpression as ft, runInOrmWriteScope as g, takeRowsWithinByteBudget as gt, createOrmWriteMemo as h, stripUnsetFields as ht, AGGREGATE_RANK_TREE_TABLE as i, hardDeleteRow as it, collectMutationRowsBounded as j, buildForeignKeyGraph as k, getRankIndexDefinitions as l, resolveOrmRuntimeDefaults as lt, runInOrmWriteBatch as m, splitReturningSelection as mt, AGGREGATE_EXTREMA_TABLE as n, getTableName as nt, aggregateExtension as o, normalizeDateFieldsForWrite as ot, runInOrmUserCallback as p, softDeleteRow as pt, getChecks as q, AGGREGATE_MEMBER_TABLE as r, getUniqueIndexes as rt, rankAggregateName as s, normalizeTemporalComparableValue as st, AGGREGATE_BUCKET_TABLE as t, getTableDeleteConfig as tt, enqueueOrmWriteBatch as u, returningSelectionReadsCreationTime as ut, markOrmTransactionAnchor as v, unsetFieldsOf as vt, ensureAggregateAllowedForRls as w, mapWithConcurrency as wt, createAggregateError as x, compileConvexFilter as xt, AGGREGATE_ERROR as y, hasLifecycleHooks as yt, enforcePolymorphicWrite as z };

package/dist/server/index.d.ts

@@ -1,5 +1,6 @@
-import { $ as ActionProcedureBuilder, A as CRPCError, B as RuntimeEnv, C as createProcedureHandlerFactory, Ct as zCustomQuery, D as WithHttpRouter, Dt as zodToConvex, E as typedProcedureResolver, Et as zodOutputToConvexFields, F as getCRPCErrorFromUnknown, G as createLazyCaller, H as ConvexContext, I as getHTTPStatusCodeFromError, J as ServerCaller, K as CallerMeta, L as isCRPCError, M as CRPCErrorData, N as CRPC_ERROR_CODES_BY_KEY, O as inferApiInputs, Ot as zodToConvexFields, P as CRPC_ERROR_CODE_TO_HTTP, Q as getGeneratedValue, R as toCRPCError, S as createProcedureCallerFactory, St as zCustomMutation, T as getGeneratedFunctionReference, Tt as zodOutputToConvex, U as createCallerFactory, V as createEnv, W as LazyCaller, X as createApiLeaf, Y as createServerCaller, Z as createGeneratedFunctionReference, _ as ProcedureSchedulableCallerFromRegistry, _t as ZodValidatorFromConvex, a as CreateProcedureCallerFactoryOptions, at as initCRPC, b as createGenericCallerFactory, bt as withSystemFields, c as GeneratedRegistryCallerFactory, ct as extractPathParams, d as GeneratedRegistryHandlerForContext, dt as ConvexValidatorFromZod, et as CRPCFunctionTypeHint, f as ProcedureActionCallerFromRegistry, ft as ConvexValidatorFromZodOutput, g as ProcedureFromFunctionReference, gt as ZodFromValidatorBase, h as ProcedureDefinition, ht as Zid, i as registerProcedureNameLookup, it as createMiddlewareFactory, j as CRPCErrorCode, k as inferApiOutputs, l as GeneratedRegistryCallerForContext, lt as handleHttpError, m as ProcedureCallerFromRegistry, mt as ZCustomCtx, n as ProcedureNameLookup, nt as ProcedureBuilder, o as GeneratedProcedureRegistry, ot as HttpProcedureBuilder, p as ProcedureCaller, pt as CustomBuilder, q as CallerOpts, r as inferProcedureNameFromCallsite, rt as QueryProcedureBuilder, s as GeneratedProcedureRegistryEntry, st as createHttpProcedureBuilder, t as ProcedureNameEntry, tt as MutationProcedureBuilder, u as GeneratedRegistryHandlerFactory, ut as matchPathParams, v as ProcedureScheduleCallerFromRegistry, vt as convexToZod, w as defineProcedure, wt as zid, x as createGenericHandlerFactory, xt as zCustomAction, y as createGeneratedRegistryRuntime, yt as convexToZodFields, z as CreateEnvOptions } from "../procedure-name-DPYyLiVS.js";
-import { A as HttpProcedureBuilderDef, C as extractRouteMap, D as HttpHandlerOpts, E as HttpActionHandler, M as InferHttpInput, N as ProcedureMeta, O as HttpMethod, S as createHttpRouterFactory, T as HttpActionConstructor, _ as CRPCHttpRouter, b as HttpRouterWithHono, j as HttpRouteDefinition, k as HttpProcedure, v as HttpRouterDef, w as CRPCHonoHandler, x as createHttpRouter, y as HttpRouterRecord } from "../http-types-BhhPZtwa.js";
-import { a as MergeZodObjects, c as MiddlewareMarker, d as MiddlewareProcedureType, f as MiddlewareResult, g as UnsetMarker, h as Simplify, i as IntersectIfDefined, l as MiddlewareNext, m as ResolveIfSet, n as AnyMiddlewareBuilder, o as MiddlewareBuilder, p as Overwrite, r as GetRawInputFn, s as MiddlewareFunction, t as AnyMiddleware, u as MiddlewareProcedureInfo } from "../types-Bkeicpo6.js";
-import { a as isMutationCtx, c as isSchedulerCtx, d as requireQueryCtx, f as requireRunMutationCtx, i as isActionCtx, l as requireActionCtx, n as RunMutationCtx, o as isQueryCtx, p as requireSchedulerCtx, r as SchedulerCtx, s as isRunMutationCtx, t as GenericCtx, u as requireMutationCtx } from "../context-utils-Cbv4r0AA.js";
+import { a as CallerMeta, c as createServerCaller, i as createLazyCaller, n as createCallerFactory, o as CallerOpts, r as LazyCaller, s as ServerCaller, t as ConvexContext } from "../caller-factory-C3pcbzo0.js";
+import { $ as createHttpProcedureBuilder, A as CRPCError, B as RuntimeEnv, C as createProcedureHandlerFactory, D as WithHttpRouter, E as typedProcedureResolver, F as getCRPCErrorFromUnknown, G as ActionProcedureBuilder, H as createApiLeaf, I as getHTTPStatusCodeFromError, J as ProcedureBuilder, K as CRPCFunctionTypeHint, L as isCRPCError, M as CRPCErrorData, N as CRPC_ERROR_CODES_BY_KEY, O as inferApiInputs, P as CRPC_ERROR_CODE_TO_HTTP, Q as HttpProcedureBuilder, R as toCRPCError, S as createProcedureCallerFactory, T as getGeneratedFunctionReference, U as createGeneratedFunctionReference, V as createEnv, W as getGeneratedValue, X as createMiddlewareFactory, Y as QueryProcedureBuilder, Z as initCRPC, _ as ProcedureSchedulableCallerFromRegistry, _t as zodOutputToConvex, a as CreateProcedureCallerFactoryOptions, at as CustomBuilder, b as createGenericCallerFactory, bt as zodToConvexFields, c as GeneratedRegistryCallerFactory, ct as ZodFromValidatorBase, d as GeneratedRegistryHandlerForContext, dt as convexToZodFields, et as extractPathParams, f as ProcedureActionCallerFromRegistry, ft as withSystemFields, g as ProcedureFromFunctionReference, gt as zid, h as ProcedureDefinition, ht as zCustomQuery, i as registerProcedureNameLookup, it as ConvexValidatorFromZodOutput, j as CRPCErrorCode, k as inferApiOutputs, l as GeneratedRegistryCallerForContext, lt as ZodValidatorFromConvex, m as ProcedureCallerFromRegistry, mt as zCustomMutation, n as ProcedureNameLookup, nt as matchPathParams, o as GeneratedProcedureRegistry, ot as ZCustomCtx, p as ProcedureCaller, pt as zCustomAction, q as MutationProcedureBuilder, r as inferProcedureNameFromCallsite, rt as ConvexValidatorFromZod, s as GeneratedProcedureRegistryEntry, st as Zid, t as ProcedureNameEntry, tt as handleHttpError, u as GeneratedRegistryHandlerFactory, ut as convexToZod, v as ProcedureScheduleCallerFromRegistry, vt as zodOutputToConvexFields, w as defineProcedure, x as createGenericHandlerFactory, y as createGeneratedRegistryRuntime, yt as zodToConvex, z as CreateEnvOptions } from "../procedure-name-kn-awLk1.js";
+import { a as MergeZodObjects, c as MiddlewareMarker, d as MiddlewareProcedureType, f as MiddlewareResult, g as UnsetMarker, h as Simplify, i as IntersectIfDefined, l as MiddlewareNext, m as ResolveIfSet, n as AnyMiddlewareBuilder, o as MiddlewareBuilder, p as Overwrite, r as GetRawInputFn, s as MiddlewareFunction, t as AnyMiddleware, u as MiddlewareProcedureInfo } from "../types-CzGsrLrY.js";
+import { A as HttpProcedureBuilderDef, C as extractRouteMap, D as HttpHandlerOpts, E as HttpActionHandler, M as InferHttpInput, N as ProcedureMeta, O as HttpMethod, S as createHttpRouterFactory, T as HttpActionConstructor, _ as CRPCHttpRouter, b as HttpRouterWithHono, j as HttpRouteDefinition, k as HttpProcedure, v as HttpRouterDef, w as CRPCHonoHandler, x as createHttpRouter, y as HttpRouterRecord } from "../http-types-8FBr10yl.js";
+import { a as isMutationCtx, c as isSchedulerCtx, d as requireQueryCtx, f as requireRunMutationCtx, i as isActionCtx, l as requireActionCtx, n as RunMutationCtx, o as isQueryCtx, p as requireSchedulerCtx, r as SchedulerCtx, s as isRunMutationCtx, t as GenericCtx, u as requireMutationCtx } from "../context-utils-ax351iFc.js";
 export { ActionProcedureBuilder, AnyMiddleware, AnyMiddlewareBuilder, CRPCError, CRPCErrorCode, CRPCErrorData, CRPCFunctionTypeHint, CRPCHonoHandler, CRPCHttpRouter, CRPC_ERROR_CODES_BY_KEY, CRPC_ERROR_CODE_TO_HTTP, CallerMeta, CallerOpts, ConvexContext, ConvexValidatorFromZod, ConvexValidatorFromZodOutput, CreateEnvOptions, CreateProcedureCallerFactoryOptions, CustomBuilder, GeneratedProcedureRegistry, GeneratedProcedureRegistryEntry, GeneratedRegistryCallerFactory, GeneratedRegistryCallerForContext, GeneratedRegistryHandlerFactory, GeneratedRegistryHandlerForContext, GenericCtx, GetRawInputFn, HttpActionConstructor, HttpActionHandler, HttpHandlerOpts, HttpMethod, HttpProcedure, HttpProcedureBuilder, HttpProcedureBuilderDef, HttpRouteDefinition, HttpRouterDef, HttpRouterRecord, HttpRouterWithHono, InferHttpInput, IntersectIfDefined, LazyCaller, MergeZodObjects, MiddlewareBuilder, MiddlewareFunction, MiddlewareMarker, MiddlewareNext, MiddlewareProcedureInfo, MiddlewareProcedureType, MiddlewareResult, MutationProcedureBuilder, Overwrite, ProcedureActionCallerFromRegistry, ProcedureBuilder, ProcedureCaller, ProcedureCallerFromRegistry, ProcedureDefinition, ProcedureFromFunctionReference, ProcedureMeta, ProcedureNameEntry, ProcedureNameLookup, ProcedureSchedulableCallerFromRegistry, ProcedureScheduleCallerFromRegistry, QueryProcedureBuilder, ResolveIfSet, RunMutationCtx, RuntimeEnv, SchedulerCtx, ServerCaller, Simplify, UnsetMarker, WithHttpRouter, ZCustomCtx, Zid, ZodFromValidatorBase, ZodValidatorFromConvex, convexToZod, convexToZodFields, createApiLeaf, createCallerFactory, createEnv, createGeneratedFunctionReference, createGeneratedRegistryRuntime, createGenericCallerFactory, createGenericHandlerFactory, createHttpProcedureBuilder, createHttpRouter, createHttpRouterFactory, createLazyCaller, createMiddlewareFactory, createProcedureCallerFactory, createProcedureHandlerFactory, createServerCaller, defineProcedure, extractPathParams, extractRouteMap, getCRPCErrorFromUnknown, getGeneratedFunctionReference, getGeneratedValue, getHTTPStatusCodeFromError, handleHttpError, inferApiInputs, inferApiOutputs, inferProcedureNameFromCallsite, initCRPC, isActionCtx, isCRPCError, isMutationCtx, isQueryCtx, isRunMutationCtx, isSchedulerCtx, matchPathParams, registerProcedureNameLookup, requireActionCtx, requireMutationCtx, requireQueryCtx, requireRunMutationCtx, requireSchedulerCtx, toCRPCError, typedProcedureResolver, withSystemFields, zCustomAction, zCustomMutation, zCustomQuery, zid, zodOutputToConvex, zodOutputToConvexFields, zodToConvex, zodToConvexFields };

package/dist/server/index.js

@@ -1,6 +1,6 @@
 import { a as isMutationCtx, c as isSchedulerCtx, d as requireQueryCtx, f as requireRunMutationCtx, i as isActionCtx, l as requireActionCtx, n as createGeneratedFunctionReference, o as isQueryCtx, p as requireSchedulerCtx, r as getGeneratedValue, s as isRunMutationCtx, t as createApiLeaf, u as requireMutationCtx } from "../api-entry-Buvjl9hn.js";
 import { n as createLazyCaller, r as createServerCaller, t as createCallerFactory } from "../caller-factory-C-N540BC.js";
-import { A as zid, C as toCRPCError, D as zCustomAction, E as withSystemFields, M as zodOutputToConvexFields, N as zodToConvex, O as zCustomMutation, P as zodToConvexFields, S as isCRPCError, T as convexToZodFields, _ as CRPCError, a as createMiddlewareFactory, b as getCRPCErrorFromUnknown, c as registerProcedureNameLookup, d as createHttpRouterFactory, f as extractRouteMap, g as matchPathParams, h as handleHttpError, i as QueryProcedureBuilder, j as zodOutputToConvex, k as zCustomQuery, l as HttpRouterWithHono, m as extractPathParams, n as MutationProcedureBuilder, o as initCRPC, p as createHttpProcedureBuilder, r as ProcedureBuilder, s as inferProcedureNameFromCallsite, t as ActionProcedureBuilder, u as createHttpRouter, v as CRPC_ERROR_CODES_BY_KEY, w as convexToZod, x as getHTTPStatusCodeFromError, y as CRPC_ERROR_CODE_TO_HTTP } from "../builder-Cyd5nCxZ.js";
-import { a as createProcedureHandlerFactory, c as typedProcedureResolver, i as createProcedureCallerFactory, l as createEnv, n as createGenericCallerFactory, o as defineProcedure, r as createGenericHandlerFactory, s as getGeneratedFunctionReference, t as createGeneratedRegistryRuntime } from "../procedure-caller-DgMiD0-a.js";
+import { A as zid, C as toCRPCError, D as zCustomAction, E as withSystemFields, M as zodOutputToConvexFields, N as zodToConvex, O as zCustomMutation, P as zodToConvexFields, S as isCRPCError, T as convexToZodFields, _ as CRPCError, a as createMiddlewareFactory, b as getCRPCErrorFromUnknown, c as registerProcedureNameLookup, d as createHttpRouterFactory, f as extractRouteMap, g as matchPathParams, h as handleHttpError, i as QueryProcedureBuilder, j as zodOutputToConvex, k as zCustomQuery, l as HttpRouterWithHono, m as extractPathParams, n as MutationProcedureBuilder, o as initCRPC, p as createHttpProcedureBuilder, r as ProcedureBuilder, s as inferProcedureNameFromCallsite, t as ActionProcedureBuilder, u as createHttpRouter, v as CRPC_ERROR_CODES_BY_KEY, w as convexToZod, x as getHTTPStatusCodeFromError, y as CRPC_ERROR_CODE_TO_HTTP } from "../builder-DDYTlmTB.js";
+import { a as createProcedureHandlerFactory, c as typedProcedureResolver, i as createProcedureCallerFactory, l as createEnv, n as createGenericCallerFactory, o as defineProcedure, r as createGenericHandlerFactory, s as getGeneratedFunctionReference, t as createGeneratedRegistryRuntime } from "../procedure-caller-DgGF_hA8.js";
 
 export { ActionProcedureBuilder, CRPCError, CRPC_ERROR_CODES_BY_KEY, CRPC_ERROR_CODE_TO_HTTP, HttpRouterWithHono, MutationProcedureBuilder, ProcedureBuilder, QueryProcedureBuilder, convexToZod, convexToZodFields, createApiLeaf, createCallerFactory, createEnv, createGeneratedFunctionReference, createGeneratedRegistryRuntime, createGenericCallerFactory, createGenericHandlerFactory, createHttpProcedureBuilder, createHttpRouter, createHttpRouterFactory, createLazyCaller, createMiddlewareFactory, createProcedureCallerFactory, createProcedureHandlerFactory, createServerCaller, defineProcedure, extractPathParams, extractRouteMap, getCRPCErrorFromUnknown, getGeneratedFunctionReference, getGeneratedValue, getHTTPStatusCodeFromError, handleHttpError, inferProcedureNameFromCallsite, initCRPC, isActionCtx, isCRPCError, isMutationCtx, isQueryCtx, isRunMutationCtx, isSchedulerCtx, matchPathParams, registerProcedureNameLookup, requireActionCtx, requireMutationCtx, requireQueryCtx, requireRunMutationCtx, requireSchedulerCtx, toCRPCError, typedProcedureResolver, withSystemFields, zCustomAction, zCustomMutation, zCustomQuery, zid, zodOutputToConvex, zodOutputToConvexFields, zodToConvex, zodToConvexFields };

package/dist/solid/index.d.ts

@@ -60,8 +60,8 @@ type ConvexQueryHookOptions = {
   /** Skip query silently when unauthenticated (default: false, calls onQueryUnauthorized) */skipUnauth?: boolean; /** Set to false to fetch once without subscribing (default: true) */
   subscribe?: boolean;
 };
-/** Extract input args without cursor/limit (user's filter args only) */
-type InfiniteQueryInput<TInput> = Omit<TInput, 'cursor' | 'limit'>;
+/** Extract user args without hook-owned pagination transport fields */
+type InfiniteQueryInput<TInput> = Omit<TInput, 'cursor' | 'endCursor' | 'limit'>;
 /** Extract item type from PaginationResult<T> */
 type ExtractPaginatedItem<TOutput> = TOutput extends {
   page: (infer T)[];
@@ -1429,7 +1429,7 @@ declare const getConvexQueryClientSingleton: ({
  * Pagination state persisted in queryClient.
  * Enables scroll restoration when navigating back to a paginated list.
  *
- * Uses flat { cursor, limit } structure like tRPC.
+ * Uses flat { cursor, endCursor, limit } structure like tRPC.
  */
 type PaginationState = {
   id: number;
@@ -1438,13 +1438,12 @@ type PaginationState = {
   queries: Record<number, {
     /** Flat pagination args - tRPC style */args: Record<string, unknown> & {
       cursor: string | null;
+      endCursor?: string | null;
       limit?: number; /** Internal pagination ID for subscription management */
       __paginationId?: number;
     };
-    endCursor?: string | null;
   }>;
-  version: number; /** Recovery key to prevent infinite recovery loops */
-  autoRecoveryAttempted?: string;
+  version: number;
 };
 type PaginationStatus = 'CanLoadMore' | 'Exhausted' | 'LoadingFirstPage' | 'LoadingMore';
 /** Return type for infinite query hooks */

package/dist/solid/index.js

@@ -2935,6 +2935,12 @@ const getConvexQueryClientSingleton = ({ authStore, convex, queryClient, symbolK
 //#endregion
 //#region src/internal/pagination.ts
 const shouldSplitPaginationPage = (page, initialNumItems) => Boolean(page.splitCursor) && (page.pageStatus === "SplitRecommended" || page.pageStatus === "SplitRequired" || initialNumItems !== void 0 && page.page.length > initialNumItems * 2);
+const isInvalidPaginationCursor = (error) => {
+	if (error instanceof Error && error.message.includes("InvalidCursor")) return true;
+	if (!error || typeof error !== "object" || !("data" in error)) return false;
+	const data = error.data;
+	return Boolean(data && typeof data === "object" && "isConvexSystemError" in data && data.isConvexSystemError === true && "paginationError" in data && data.paginationError === "InvalidCursor");
+};
 
 //#endregion
 //#region src/solid/create-queries-results.ts
@@ -3020,7 +3026,7 @@ const aggregatePages = (results, hasPlaceholderData) => {
 		error,
 		failureReason: error,
 		isError: results.some((r) => r.isError),
-		isFetchNextPageError: results.length > 1 && (results.at(-1)?.isError ?? false),
+		isFetchNextPageError: results.slice(1).some((result) => result.isError),
 		isFetching,
 		isLoading: status === "LoadingFirstPage",
 		isPlaceholderData,
@@ -3030,72 +3036,18 @@ const aggregatePages = (results, hasPlaceholderData) => {
 		status
 	};
 };
-/** Build a unique key for recovery attempt detection */
-const buildRecoveryKey = (pageKeys, page0Cursor, page0UpdatedAt) => JSON.stringify({
-	pageKeys,
-	page0Cursor,
-	page0UpdatedAt
-});
 /**
 * Hook for auto-recovering from stale cursors after WebSocket reconnection.
 *
 * When Convex WebSocket reconnects, page 0 (cursor: null) resubscribes and
 * gets fresh data. However, pages 1+ may have stale cursors that fail.
 *
-* This hook detects this pattern and creates a recovery page that fetches
-* enough items to cover the lost pages, preserving the user's scroll position.
+* This hook discards the invalid cursor chain and restarts from page one.
 */
-const useStaleCursorRecovery = ({ argsObject, combined, limit, pageResults, setState, state }) => {
-	createEffect(on([
-		() => combined.isFetchNextPageError,
-		pageResults,
-		() => state().pageKeys,
-		() => state().queries,
-		() => state().autoRecoveryAttempted,
-		argsObject
-	], () => {
+const useStaleCursorRecovery = ({ combined, pageResults, resetPagination }) => {
+	createEffect(on([() => combined.isFetchNextPageError, pageResults], () => {
 		if (!combined.isFetchNextPageError) return;
-		const results = pageResults();
-		const page0Result = results[0];
-		const page0Data = page0Result?.data;
-		const page0UpdatedAt = page0Result?.dataUpdatedAt ?? 0;
-		const hasPage0Data = page0Data !== void 0 && !page0Result?.isError;
-		const hasSubsequentErrors = results.slice(1).some((q) => q?.isError && !q?.isFetching);
-		if (!hasPage0Data || !hasSubsequentErrors || !page0Data?.continueCursor) return;
-		const currentState = state();
-		const recoveryKey = buildRecoveryKey(currentState.pageKeys, page0Data.continueCursor, page0UpdatedAt);
-		if (currentState.autoRecoveryAttempted === recoveryKey) return;
-		const erroredPageKeys = currentState.pageKeys.filter((_, i) => i > 0 && results[i]?.isError);
-		const itemsToRecover = erroredPageKeys.reduce((sum, key) => {
-			return sum + (currentState.queries[key]?.args?.limit ?? limit ?? 20);
-		}, 0);
-		console.warn("[Pagination] Auto-recovering from stale cursors", {
-			erroredPages: erroredPageKeys.length,
-			itemsToRecover
-		});
-		setState((prev) => ({
-			...prev,
-			id: prev.id,
-			nextPageKey: 2,
-			pageKeys: [prev.pageKeys[0], 1],
-			queries: {
-				[prev.pageKeys[0]]: prev.queries[prev.pageKeys[0]],
-				1: { args: {
-					...argsObject(),
-					cursor: page0Data.continueCursor,
-					limit: Math.min(itemsToRecover + (limit ?? 20), 500),
-					__paginationId: prev.id
-				} }
-			},
-			version: prev.version + 1,
-			autoRecoveryAttempted: recoveryKey
-		}));
-	}));
-	createEffect(on([() => combined.status, () => state().autoRecoveryAttempted], () => {
-		if ((combined.status === "CanLoadMore" || combined.status === "Exhausted") && state().autoRecoveryAttempted) setState((prev) => ({
-			...prev,
-			autoRecoveryAttempted: void 0
-		}));
+		if (pageResults().slice(1).some((result) => result?.isError && !result.isFetching && isInvalidPaginationCursor(result.error))) resetPagination();
 	}));
 };
 /**
@@ -3232,12 +3184,9 @@ const useInfiniteQueryInternal = (query, args, options) => {
 	const [combined, setCombined] = createStore(derive());
 	createRenderEffect(() => setCombined(derive()));
 	useStaleCursorRecovery({
-		argsObject,
 		combined,
-		limit,
 		pageResults,
-		setState,
-		state
+		resetPagination: () => setState(createInitialState())
 	});
 	createEffect(on([
 		pageResults,
@@ -3252,15 +3201,17 @@ const useInfiniteQueryInternal = (query, args, options) => {
 				const page = pageQuery.data;
 				const pageKey = state().pageKeys[i];
 				const pageState = state().queries[pageKey];
-				if (shouldSplitPaginationPage(page, limit) && pageState && !pageState.endCursor) {
+				if (shouldSplitPaginationPage(page, limit) && pageState && pageState.args.endCursor !== page.splitCursor) {
 					setState((prev) => {
 						const currentPageState = prev.queries[pageKey];
-						if (!currentPageState || currentPageState.endCursor) return prev;
+						if (!currentPageState || currentPageState.args.endCursor === page.splitCursor) return prev;
 						const newKey = prev.nextPageKey;
 						const splitCursor = page.splitCursor;
+						const endCursor = currentPageState.args.endCursor ?? page.continueCursor;
 						const splitPageArgs = {
 							...argsObject(),
 							cursor: splitCursor,
+							endCursor,
 							limit: currentPageState.args.limit,
 							__paginationId: prev.id
 						};
@@ -3275,7 +3226,10 @@ const useInfiniteQueryInternal = (query, args, options) => {
 								...prev.queries,
 								[pageKey]: {
 									...currentPageState,
-									endCursor: splitCursor
+									args: {
+										...currentPageState.args,
+										endCursor: splitCursor
+									}
 								},
 								[newKey]: { args: splitPageArgs }
 							}

package/dist/transformer-BEkxlnss.d.ts

@@ -0,0 +1,78 @@
+//#region src/crpc/transformer.d.ts
+/**
+ * Generic transformer contract (mirrors tRPC shape).
+ */
+interface DataTransformer {
+  deserialize(object: any): any;
+  serialize(object: any): any;
+}
+/**
+ * Separate input/output transformers.
+ */
+interface CombinedDataTransformer {
+  input: DataTransformer;
+  output: DataTransformer;
+}
+/**
+ * Transformer config accepted by cRPC.
+ */
+type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
+/**
+ * Extensible tagged wire codec.
+ */
+interface WireCodec {
+  decode(value: unknown): unknown;
+  encode(value: unknown): unknown;
+  isType(value: unknown): boolean;
+  /**
+   * Declares that `isType` only ever claims a value where
+   * `typeof value === 'object' && value !== null` - never a primitive, a
+   * function, `null` or `undefined`.
+   *
+   * Lets `serialize` skip codec dispatch on primitives, which are the majority
+   * of visited nodes. It is opt-in because an arbitrary predicate cannot be
+   * classified by sampling values: a codec that claims, say, one specific
+   * number would be misread as object-only and silently lose its encoding.
+   * Codecs that leave it unset keep full dispatch.
+   */
+  readonly objectsOnly?: boolean;
+  readonly tag: `$${string}`;
+}
+/**
+ * Date wire tag (Convex-style reserved key).
+ */
+declare const DATE_CODEC_TAG = "$date";
+/**
+ * Built-in Date codec.
+ */
+declare const dateWireCodec: WireCodec;
+/**
+ * Build a recursive tagged transformer from codecs.
+ */
+declare const createTaggedTransformer: (codecs: readonly WireCodec[]) => DataTransformer;
+/**
+ * Default cRPC transformer (Date-enabled).
+ */
+declare const defaultCRPCTransformer: DataTransformer;
+/**
+ * Normalize transformer config to split input/output shape.
+ * User transformers are additive and always composed with default Date handling.
+ *
+ * Idempotent: passing a transformer this function already resolved returns it
+ * unchanged.
+ */
+declare const getTransformer: (transformer?: DataTransformerOptions) => CombinedDataTransformer;
+/**
+ * Encode request payloads (input direction).
+ */
+declare const encodeWire: (value: unknown, transformer?: DataTransformerOptions) => unknown;
+/**
+ * Decode response payloads (output direction).
+ */
+declare const decodeWire: (value: unknown, transformer?: DataTransformerOptions) => unknown;
+/**
+ * Exposed identity transformer for advanced composition.
+ */
+declare const identityTransformer: CombinedDataTransformer;
+//#endregion
+export { WireCodec as a, decodeWire as c, getTransformer as d, identityTransformer as f, DataTransformerOptions as i, defaultCRPCTransformer as l, DATE_CODEC_TAG as n, createTaggedTransformer as o, DataTransformer as r, dateWireCodec as s, CombinedDataTransformer as t, encodeWire as u };

package/dist/{types-BXpu7xIU.d.ts → types-Cl0utsTL.d.ts}

@@ -1,4 +1,5 @@
-import { P as CombinedDataTransformer, r as HttpClientError } from "./http-types-BhhPZtwa.js";
+import { t as CombinedDataTransformer } from "./transformer-BEkxlnss.js";
+import { r as HttpClientError } from "./http-types-8FBr10yl.js";
 import { FunctionArgs, FunctionReference, FunctionReturnType } from "convex/server";
 
 //#region src/crpc/http-client.d.ts
@@ -148,8 +149,8 @@ type PaginationOpts = {
   maximumRowsRead?: number;
   maximumBytesRead?: number;
 };
-/** Extract input args without cursor/limit (user's filter args only) */
-type InfiniteQueryInput<TInput> = Omit<TInput, 'cursor' | 'limit'>;
+/** Extract user args without hook-owned pagination transport fields */
+type InfiniteQueryInput<TInput> = Omit<TInput, 'cursor' | 'endCursor' | 'limit'>;
 /** Extract item type from PaginationResult<T> */
 type ExtractPaginatedItem<TOutput> = TOutput extends {
   page: (infer T)[];