@nkzw/fate 0.1.0 → 0.1.2

package/README.md

@@ -552,18 +552,9 @@ const PostView = view<Post>()({
 Now you can apply the `useListView` hook inside of your `PostCard` component to read the list of comments and load more comments when needed:
 
 ```tsx
-export function PostCard({
-  detail,
-  post: postRef,
-}: {
-  detail?: boolean;
-  post: ViewRef<'Post'>;
-}) {
+export function PostCard({ detail, post: postRef }: { detail?: boolean; post: ViewRef<'Post'> }) {
   const post = useView(PostView, postRef);
-  const [comments, loadNext] = useListView(
-    CommentConnectionView,
-    post.comments,
-  );
+  const [comments, loadNext] = useListView(CommentConnectionView, post.comments);
 
   return (
     <div>
@@ -615,10 +606,7 @@ If you are not using an async component library, you can use React's `useTransit
 const LikeButton = ({ post }: { post: { id: string; likes: number } }) => {
   const fate = useFateClient();
   const [, startTransition] = useTransition();
-  const [result, like, isPending] = useActionState(
-    fate.actions.post.like,
-    null,
-  );
+  const [result, like, isPending] = useActionState(fate.actions.post.like, null);
 
   return (
     <button
@@ -805,10 +793,7 @@ const [result, like] = useActionState(fate.actions.post.like, null);
 useEffect(() => {
   if (result?.error) {
     // Reset the action state after 3 seconds.
-    const timeout = setTimeout(
-      () => startTransition(() => like('reset')),
-      3000,
-    );
+    const timeout = setTimeout(() => startTransition(() => like('reset')), 3000);
     return () => clearTimeout(timeout);
   }
 }, [like, result]);

package/lib/index.d.mts

@@ -1,4 +1,4 @@
-import { A as ViewSelection, B as RequestOptions, C as TypeConfig, D as ViewEntity, E as ViewData, F as isViewTag, H as Transport, I as FateMutations, L as mutation, M as ViewTag, N as __FateEntityBrand, O as ViewEntityName, P as __FateSelectionBrand, R as FateClient, S as Snapshot, T as View, U as createTRPCTransport, V as createClient, W as getSelectionPlan, _ as Pagination, a as Entity, b as RootDefinition, c as FateThenable, d as MutationDefinition, f as MutationEntity, g as NodesItem, h as MutationResult, i as ConnectionTag, j as ViewSnapshot, k as ViewRef, l as ListItem, m as MutationInput, n as ConnectionMetadata, o as EntityId, p as MutationIdentifier, r as ConnectionRef, s as FateRoots, t as AnyRecord, u as Mask, v as Request, w as TypeName, x as Selection, y as RequestResult, z as RequestMode } from "./types-CNKGKRtz.mjs";
+import { A as ViewSelection, B as RequestOptions, C as TypeConfig, D as ViewEntity, E as ViewData, F as isViewTag, G as getSelectionPlan, H as Transport, I as FateMutations, L as mutation, M as ViewTag, N as __FateEntityBrand, O as ViewEntityName, P as __FateSelectionBrand, R as FateClient, S as Snapshot, T as View, U as createTRPCTransport, V as createClient, _ as Pagination, a as Entity, b as RootDefinition, c as FateThenable, d as MutationDefinition, f as MutationEntity, g as NodesItem, h as MutationResult, i as ConnectionTag, j as ViewSnapshot, k as ViewRef, l as ListItem, m as MutationInput, n as ConnectionMetadata, o as EntityId, p as MutationIdentifier, r as ConnectionRef, s as FateRoots, t as AnyRecord, u as Mask, v as Request, w as TypeName, x as Selection, y as RequestResult, z as RequestMode } from "./types-Djlh7mMH.mjs";
 
 //#region src/root.d.ts
 

package/lib/index.mjs

@@ -264,7 +264,7 @@ function intersects(a, b) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@trpc+server@11.7.2_typescript@5.9.3/node_modules/@trpc/server/dist/getErrorShape-BH60iMC2.mjs
+//#region ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/getErrorShape-vC8mUXJD.mjs
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -689,39 +689,45 @@ function wrapMutation(client, identifier) {
 			if (id$1 == null) throw new Error(`fate: Mutation '${identifier.key}' requires an 'id' to delete.`);
 			client.deleteRecord(identifier.entity, id$1, snapshots, listSnapshots);
 		}
-		try {
-			const result = await client.executeMutation(identifier.key, input, selection, {
-				args,
-				plan
-			});
-			if (result && typeof result === "object" && (!deleteRecord || Boolean(view$1))) {
-				const select = collectImplicitSelectedPaths(result);
-				const pendingMask = optimisticEntityId ? client.getPendingOptimisticMask(optimisticEntityId, { excludeToken: optimisticToken }) : null;
-				const filteredSelection = optimisticEntityId ? client.filterSelectionForPendingOptimistics(optimisticEntityId, select, { excludeToken: optimisticToken }) : select;
-				client.write(identifier.entity, result, filteredSelection, void 0, plan, null, pendingMask, insert);
-				if (deleteRecord && id$1 != null) client.deleteRecord(identifier.entity, id$1);
-				const resultId = maybeGetId(config.getId, result);
-				if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
-			}
-			return {
-				error: void 0,
-				result
-			};
-		} catch (error) {
-			client.clearOptimisticUpdate(optimisticToken);
-			if (snapshots.size > 0) for (const [id$2, snapshot] of snapshots) client.restore(id$2, snapshot);
-			if (listSnapshots && listSnapshots.size > 0) for (const [name, list] of listSnapshots) client.restoreList(name, list);
-			if (error instanceof Error) {
-				const { data } = error;
-				if ((data ? categorizeTRPCError(getHTTPStatusCodeFromError(data)) : "boundary") === "boundary") throw error;
+		const performMutation = async () => {
+			try {
+				const result = await client.executeMutation(identifier.key, input, selection, {
+					args,
+					plan
+				});
+				if (result && typeof result === "object" && (!deleteRecord || Boolean(view$1))) {
+					const select = collectImplicitSelectedPaths(result);
+					const pendingMask = optimisticEntityId ? client.getPendingOptimisticMask(optimisticEntityId, { excludeToken: optimisticToken }) : null;
+					const filteredSelection = optimisticEntityId ? client.filterSelectionForPendingOptimistics(optimisticEntityId, select, { excludeToken: optimisticToken }) : select;
+					client.write(identifier.entity, result, filteredSelection, void 0, plan, null, pendingMask, insert);
+					if (deleteRecord && id$1 != null) client.deleteRecord(identifier.entity, id$1);
+					const resultId = maybeGetId(config.getId, result);
+					if (optimisticEntityId && resultId != null) client.resolveOptimisticEntity(optimisticEntityId, toEntityId(identifier.entity, resultId));
+					if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
+				}
 				return {
-					error,
-					result: void 0
+					error: void 0,
+					result
 				};
-			} else throw new Error(`fate: Mutation '${identifier.key}' failed.`);
-		} finally {
-			client.clearOptimisticUpdate(optimisticToken);
-		}
+			} catch (error) {
+				client.clearOptimisticUpdate(optimisticToken);
+				if (snapshots.size > 0) for (const [id$2, snapshot] of snapshots) client.restore(id$2, snapshot);
+				if (listSnapshots && listSnapshots.size > 0) for (const [name, list] of listSnapshots) client.restoreList(name, list);
+				if (error instanceof Error) {
+					const { data } = error;
+					if ((data ? categorizeTRPCError(getHTTPStatusCodeFromError(data)) : "boundary") === "boundary") throw error;
+					return {
+						error,
+						result: void 0
+					};
+				} else throw new Error(`fate: Mutation '${identifier.key}' failed.`);
+			} finally {
+				client.clearOptimisticUpdate(optimisticToken);
+			}
+		};
+		const mutationPromise = performMutation();
+		if (optimisticEntityId) client.registerPendingOptimisticMutation(optimisticEntityId, mutationPromise);
+		return mutationPromise;
 	};
 }
 function categorizeTRPCError(statusCode) {
@@ -1049,8 +1055,10 @@ var FateClient = class {
 		this.parentLists = /* @__PURE__ */ new Map();
 		this.rootLists = /* @__PURE__ */ new Map();
 		this.pending = /* @__PURE__ */ new Map();
+		this.pendingOptimisticMutations = /* @__PURE__ */ new Map();
 		this.optimisticMasks = /* @__PURE__ */ new Map();
 		this.optimisticByEntity = /* @__PURE__ */ new Map();
+		this.optimisticEntityResolutions = /* @__PURE__ */ new Map();
 		this.optimisticTokenCounter = 0;
 		this.requests = /* @__PURE__ */ new Map();
 		this.rootRequests = /* @__PURE__ */ new Map();
@@ -1177,6 +1185,11 @@ var FateClient = class {
 		}
 		if (type == null) throw new Error(`fate: Invalid view reference. Expected '__typename' to be provided as part of the reference, received '${JSON.stringify(ref)}'.`);
 		const entityId = toEntityId(type, id$1);
+		const resolvedEntityId = this.optimisticEntityResolutions.get(entityId) ?? null;
+		if (resolvedEntityId && resolvedEntityId !== entityId) {
+			const { id: resolvedId, type: resolvedType } = parseEntityId(resolvedEntityId);
+			return this.readView(view$1, createRef(resolvedType, resolvedId, view$1));
+		}
 		const viewNames = getViewNames(view$1);
 		const refViews = ref[ViewsTag];
 		if (!refViews || ![...viewNames].every((name) => refViews.has(name))) {
@@ -1204,6 +1217,14 @@ var FateClient = class {
 		}
 		if (missing.size > 0) {
 			const key = this.pendingKey(entityId, missing);
+			const pendingOptimistic = this.getPendingOptimisticMutations(entityId);
+			if (pendingOptimistic) {
+				const pending = this.pending.get(key);
+				if (pending) return pending;
+				const promise$1 = Promise.all(pendingOptimistic).then(() => this.readView(view$1, ref)).finally(() => this.pending.delete(key));
+				this.pending.set(key, promise$1);
+				return promise$1;
+			}
 			if (this.stalledRequests.has(key)) return resolveSnapshot();
 			const pendingPromise = this.pending.get(key) || null;
 			if (pendingPromise) return pendingPromise;
@@ -1257,6 +1278,24 @@ var FateClient = class {
 			} : void 0
 		};
 	}
+	registerPendingOptimisticMutation(entityId, promise) {
+		let entries = this.pendingOptimisticMutations.get(entityId);
+		if (!entries) {
+			entries = /* @__PURE__ */ new Set();
+			this.pendingOptimisticMutations.set(entityId, entries);
+		}
+		const trackedPromise = promise.catch(() => void 0);
+		entries.add(trackedPromise);
+		trackedPromise.finally(() => {
+			const current = this.pendingOptimisticMutations.get(entityId);
+			if (!current) return;
+			current.delete(trackedPromise);
+			if (current.size === 0) this.pendingOptimisticMutations.delete(entityId);
+		});
+	}
+	resolveOptimisticEntity(optimisticEntityId, resolvedEntityId) {
+		this.optimisticEntityResolutions.set(optimisticEntityId, resolvedEntityId);
+	}
 	registerOptimisticUpdate(entityId, select) {
 		if (!entityId || select.size === 0) return null;
 		const mask = fromPaths(select);
@@ -1298,6 +1337,10 @@ var FateClient = class {
 		}
 		return mask;
 	}
+	getPendingOptimisticMutations(entityId) {
+		const pending = this.pendingOptimisticMutations.get(entityId);
+		return pending && pending.size > 0 ? [...pending] : null;
+	}
 	filterSelectionForPendingOptimistics(entityId, select, options = {}) {
 		if (!entityId || select.size === 0) return select;
 		const pendingMask = this.getPendingOptimisticMask(entityId, options);

package/lib/server.d.mts

@@ -1,6 +1,5 @@
-import { t as AnyRecord } from "./types-CNKGKRtz.mjs";
+import { W as QueryProcedure, t as AnyRecord } from "./types-Djlh7mMH.mjs";
 import { z } from "zod";
-import { TRPCProcedureBuilder } from "@trpc/server";
 
 //#region src/server/dataView.d.ts
 declare const dataViewFieldsKey: unique symbol;
@@ -117,8 +116,43 @@ type ConnectionCursor = string;
 /**
  * Connection item including the node and opaque cursor.
  */
-
-type ProcedureLike<TContext> = TRPCProcedureBuilder<TContext, any, any, any, any, any, any, false>;
+type ConnectionItem<TNode> = {
+  cursor: ConnectionCursor;
+  node: TNode;
+};
+/**
+ * Pagination metadata returned with connection lists.
+ */
+type ConnectionPagination = {
+  hasNext: boolean;
+  hasPrevious: boolean;
+  nextCursor?: ConnectionCursor;
+  previousCursor?: ConnectionCursor;
+};
+/**
+ * Connection payload that mirrors what the client expects for list fields.
+ */
+type ConnectionResult<TNode> = {
+  items: Array<ConnectionItem<TNode>>;
+  pagination: ConnectionPagination;
+};
+type ProcedureLike = {
+  input: (schema: any) => {
+    query: (resolver: (options: any) => unknown) => unknown;
+  };
+};
+type ProcedureContext<TProcedure> = TProcedure extends {
+  input: (schema: any) => {
+    query: (resolver: (options: {
+      ctx: infer TContext;
+    }) => unknown) => unknown;
+  };
+} ? TContext : unknown;
+type ConnectionProcedure<TInput, TOutput> = QueryProcedure<{
+  input: TInput;
+  meta: unknown;
+  output: TOutput;
+}>;
 type QueryFn<TContext, TItem, TInput extends ConnectionInput> = (options: {
   ctx: TContext;
   cursor?: ConnectionCursor;
@@ -149,19 +183,13 @@ declare const connectionInput: z.ZodObject<{
  * Wraps a tRPC procedure to handle cursor-based pagination with consistent
  * connection semantics.
  */
-declare const withConnection: <TContext>(procedure: ProcedureLike<TContext>) => <TItem, TNode = TItem, TAdditionalInput extends AdditionalInputSchema | undefined = undefined>({
-  defaultSize,
-  getCursor,
-  input: additionalInput,
-  map,
-  query
-}: {
+declare function withConnection<TProcedure extends ProcedureLike>(procedure: TProcedure): <TItem, TNode = TItem, TAdditionalInput extends AdditionalInputSchema | undefined = undefined>(options: {
   defaultSize?: number;
   getCursor?: (node: TNode) => ConnectionCursor;
   input?: TAdditionalInput;
-  map?: MapFn<TContext, TItem, TNode, ConnectionInputWithAdditional<TAdditionalInput>>;
-  query: QueryFn<TContext, TItem, ConnectionInputWithAdditional<TAdditionalInput>>;
-}) => ReturnType<ReturnType<ProcedureLike<TContext>["input"]>["query"]>;
+  map?: MapFn<ProcedureContext<TProcedure>, TItem, TNode, ConnectionInputWithAdditional<TAdditionalInput>>;
+  query: QueryFn<ProcedureContext<TProcedure>, TItem, ConnectionInputWithAdditional<TAdditionalInput>>;
+}) => ConnectionProcedure<ConnectionInputWithAdditional<TAdditionalInput>, ConnectionResult<TNode>>;
 //#endregion
 //#region src/server/input.d.ts
 declare const byIdInput: z.ZodObject<{

package/lib/server.mjs

@@ -1,4 +1,4 @@
-import { t as isRecord } from "./record-DnhZuvUe.mjs";
+import { t as isRecord$1 } from "./record-DnhZuvUe.mjs";
 import { z } from "zod";
 
 //#region src/server/prismaSelect.ts
@@ -14,7 +14,7 @@ const toPrismaArgs = (args$1) => {
 	}
 	return prismaArgs;
 };
-const isRecord$1 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 /**
 * Narrows nested args to the slice relevant for a particular selection path.
 */
@@ -23,10 +23,10 @@ function getScopedArgs(args$1, path) {
 	const segments = path.split(".");
 	let current = args$1;
 	for (const segment of segments) {
-		if (!isRecord$1(current)) return;
+		if (!isRecord(current)) return;
 		current = current[segment];
 	}
-	return isRecord$1(current) ? current : void 0;
+	return isRecord(current) ? current : void 0;
 }
 /**
 * Builds a Prisma `select` object from flattened selection paths and optional
@@ -131,7 +131,7 @@ const assignIfChanged = (current, key, next, existing) => {
 	return current;
 };
 function toConnectionResult({ args: args$1, item, path, view }) {
-	if (!isRecord(item)) return item;
+	if (!isRecord$1(item)) return item;
 	let result = null;
 	const base = () => result ? {
 		...item,
@@ -162,7 +162,7 @@ function toConnectionResult({ args: args$1, item, path, view }) {
 			result = assignIfChanged(result, field, wrapped, current);
 			continue;
 		}
-		if (isRecord(current)) {
+		if (isRecord$1(current)) {
 			const wrapped = toConnectionResult({
 				args: args$1,
 				item: current,
@@ -177,50 +177,48 @@ function toConnectionResult({ args: args$1, item, path, view }) {
 		...result
 	} : item;
 }
-/**
-* Wraps a tRPC procedure to handle cursor-based pagination with consistent
-* connection semantics.
-*/
-const withConnection = (procedure) => ({ defaultSize = 20, getCursor = (node) => node.id, input: additionalInput, map, query }) => {
-	const inputSchema = additionalInput ? connectionInput.extend({ args: connectionArgs.and(additionalInput) }) : connectionInput;
-	return procedure.input(inputSchema).query(async (resolverOptions) => {
-		const { ctx, input } = resolverOptions;
-		const paginationArgs = paginationArgsSchema.parse(extractPaginationArgs(input.args));
-		const isBackward = paginationArgs.before !== void 0 || paginationArgs.last !== void 0;
-		const cursor = isBackward ? paginationArgs.before : paginationArgs.after;
-		const direction = isBackward ? "backward" : "forward";
-		const pageSize = paginationArgs.first ?? paginationArgs.last ?? defaultSize;
-		const rawItems = await query({
-			ctx,
-			cursor,
-			direction,
-			input,
-			skip: cursor ? 1 : void 0,
-			take: pageSize + 1
+function withConnection(procedure) {
+	return ({ defaultSize = 20, getCursor = (node) => node.id, input: additionalInput, map, query }) => {
+		const inputSchema = additionalInput ? connectionInput.extend({ args: connectionArgs.and(additionalInput) }) : connectionInput;
+		return procedure.input(inputSchema).query(async (resolverOptions) => {
+			const { ctx, input } = resolverOptions;
+			const paginationArgs = paginationArgsSchema.parse(extractPaginationArgs(input.args));
+			const isBackward = paginationArgs.before !== void 0 || paginationArgs.last !== void 0;
+			const cursor = isBackward ? paginationArgs.before : paginationArgs.after;
+			const direction = isBackward ? "backward" : "forward";
+			const pageSize = paginationArgs.first ?? paginationArgs.last ?? defaultSize;
+			const rawItems = await query({
+				ctx,
+				cursor,
+				direction,
+				input,
+				skip: cursor ? 1 : void 0,
+				take: pageSize + 1
+			});
+			const hasMore = rawItems.length > pageSize;
+			const limitedItems = isBackward ? rawItems.slice(Math.max(0, rawItems.length - pageSize)) : rawItems.slice(0, pageSize);
+			const items = (map ? await map({
+				ctx,
+				input,
+				items: limitedItems
+			}) : limitedItems).map((node) => ({
+				cursor: getCursor(node),
+				node
+			}));
+			const firstItem = items[0];
+			const lastItem = items.at(-1);
+			return {
+				items,
+				pagination: {
+					hasNext: isBackward ? Boolean(cursor) : hasMore,
+					hasPrevious: isBackward ? hasMore : Boolean(cursor),
+					nextCursor: lastItem?.cursor,
+					previousCursor: (isBackward ? hasMore : Boolean(cursor)) ? firstItem?.cursor : void 0
+				}
+			};
 		});
-		const hasMore = rawItems.length > pageSize;
-		const limitedItems = isBackward ? rawItems.slice(Math.max(0, rawItems.length - pageSize)) : rawItems.slice(0, pageSize);
-		const items = (map ? await map({
-			ctx,
-			input,
-			items: limitedItems
-		}) : limitedItems).map((node) => ({
-			cursor: getCursor(node),
-			node
-		}));
-		const firstItem = items[0];
-		const lastItem = items.at(-1);
-		return {
-			items,
-			pagination: {
-				hasNext: isBackward ? Boolean(cursor) : hasMore,
-				hasPrevious: isBackward ? hasMore : Boolean(cursor),
-				nextCursor: lastItem?.cursor,
-				previousCursor: (isBackward ? hasMore : Boolean(cursor)) ? firstItem?.cursor : void 0
-			}
-		};
-	});
-};
+	};
+}
 
 //#endregion
 //#region src/server/dataView.ts
@@ -266,7 +264,7 @@ function resolver(config) {
 const isResolverField = (field) => Boolean(field) && typeof field === "object" && "kind" in field && field.kind === "resolver";
 const isDataViewField = (field) => Boolean(field) && typeof field === "object" && "fields" in field;
 const filterToViewFields = (item, view, selectedPaths, prefix = null) => {
-	if (!isRecord(item)) return item;
+	if (!isRecord$1(item)) return item;
 	const filtered = {};
 	for (const [field, config] of Object.entries(view.fields)) {
 		const path = prefix ? `${prefix}.${field}` : field;
@@ -282,10 +280,10 @@ const filterToViewFields = (item, view, selectedPaths, prefix = null) => {
 		const value = item[field];
 		if (isDataViewField(config)) {
 			if (Array.isArray(value)) {
-				filtered[field] = value.map((entry) => isRecord(entry) ? filterToViewFields(entry, config, selectedPaths, path) : entry);
+				filtered[field] = value.map((entry) => isRecord$1(entry) ? filterToViewFields(entry, config, selectedPaths, path) : entry);
 				continue;
 			}
-			if (isRecord(value)) {
+			if (isRecord$1(value)) {
 				filtered[field] = filterToViewFields(value, config, selectedPaths, path);
 				continue;
 			}
@@ -297,7 +295,7 @@ const filterToViewFields = (item, view, selectedPaths, prefix = null) => {
 const mergeObject = (target, source) => {
 	for (const [key, value] of Object.entries(source)) {
 		const existing = target[key];
-		if (isRecord(existing) && isRecord(value)) {
+		if (isRecord$1(existing) && isRecord$1(value)) {
 			mergeObject(existing, value);
 			continue;
 		}
@@ -310,9 +308,9 @@ const ensureRelationSelect = (select, path) => {
 	let current = select;
 	for (const segment of segments) {
 		const existing = current[segment];
-		if (isRecord(existing) && "select" in existing) {
+		if (isRecord$1(existing) && "select" in existing) {
 			const relation$1 = existing;
-			if (!isRecord(relation$1.select)) relation$1.select = {};
+			if (!isRecord$1(relation$1.select)) relation$1.select = {};
 			current = relation$1.select;
 			continue;
 		}
@@ -370,12 +368,12 @@ const collectResolvers = (node, select, args$1, context) => {
 			args: args$1,
 			context
 		}) : resolver$1.select;
-		if (addition && isRecord(addition)) mergeObject(ensureRelationSelect(select, node.path), addition);
+		if (addition && isRecord$1(addition)) mergeObject(ensureRelationSelect(select, node.path), addition);
 	}
 	for (const relation of node.relations.values()) collectResolvers(relation, select, args$1, context);
 };
 const resolveNode = async ({ item, node, options: resolverOptions }) => {
-	if (!isRecord(item)) return item;
+	if (!isRecord$1(item)) return item;
 	let result = null;
 	const assign = (key, value) => {
 		if (!result) result = { ...item };

package/lib/{types-CNKGKRtz.d.mts → types-Djlh7mMH.d.mts}

@@ -1,5 +1,4 @@
 import { TRPCClient } from "@trpc/client";
-import { AnyRouter } from "@trpc/server";
 
 //#region src/mask.d.ts
 type FieldMask = {
@@ -70,6 +69,602 @@ declare class Store {
   restore(id: EntityId, snapshot: Snapshot): void;
 }
 //#endregion
+//#region ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
+//#region src/observable/types.d.ts
+interface Unsubscribable {
+  unsubscribe(): void;
+}
+interface Subscribable<TValue$1, TError> {
+  subscribe(observer: Partial<Observer<TValue$1, TError>>): Unsubscribable;
+}
+interface Observable<TValue$1, TError> extends Subscribable<TValue$1, TError> {
+  pipe(): Observable<TValue$1, TError>;
+  pipe<TValue1, TError1>(op1: OperatorFunction<TValue$1, TError, TValue1, TError1>): Observable<TValue1, TError1>;
+  pipe<TValue1, TError1, TValue2, TError2>(op1: OperatorFunction<TValue$1, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(op1: OperatorFunction<TValue$1, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(op1: OperatorFunction<TValue$1, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4, TValue5, TError5>(op1: OperatorFunction<TValue$1, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>, op5: OperatorFunction<TValue4, TError4, TValue5, TError5>): Observable<TValue2, TError2>;
+}
+interface Observer<TValue$1, TError> {
+  next: (value: TValue$1) => void;
+  error: (err: TError) => void;
+  complete: () => void;
+}
+type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
+type OperatorFunction<TValueBefore, TErrorBefore, TValueAfter, TErrorAfter> = UnaryFunction<Subscribable<TValueBefore, TErrorBefore>, Subscribable<TValueAfter, TErrorAfter>>;
+//#endregion
+//#region ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-CjQPvBRI.d.mts
+/**
+ * @public
+ */
+type MaybePromise<TType> = Promise<TType> | TType;
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+type GetRawInputFn = () => Promise<unknown>;
+type ValueOf<TObj> = TObj[keyof TObj];
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/codes.d.ts
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */
+declare const TRPC_ERROR_CODES_BY_KEY: {
+  /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */
+  readonly PARSE_ERROR: -32700;
+  /**
+   * The JSON sent is not a valid Request object.
+   */
+  readonly BAD_REQUEST: -32600;
+  readonly INTERNAL_SERVER_ERROR: -32603;
+  readonly NOT_IMPLEMENTED: -32603;
+  readonly BAD_GATEWAY: -32603;
+  readonly SERVICE_UNAVAILABLE: -32603;
+  readonly GATEWAY_TIMEOUT: -32603;
+  readonly UNAUTHORIZED: -32001;
+  readonly PAYMENT_REQUIRED: -32002;
+  readonly FORBIDDEN: -32003;
+  readonly NOT_FOUND: -32004;
+  readonly METHOD_NOT_SUPPORTED: -32005;
+  readonly TIMEOUT: -32008;
+  readonly CONFLICT: -32009;
+  readonly PRECONDITION_FAILED: -32012;
+  readonly PAYLOAD_TOO_LARGE: -32013;
+  readonly UNSUPPORTED_MEDIA_TYPE: -32015;
+  readonly UNPROCESSABLE_CONTENT: -32022;
+  readonly PRECONDITION_REQUIRED: -32028;
+  readonly TOO_MANY_REQUESTS: -32029;
+  readonly CLIENT_CLOSED_REQUEST: -32099;
+};
+type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
+type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;
+/**
+ * tRPC error codes that are considered retryable
+ * With out of the box SSE, the client will reconnect when these errors are encountered
+ */
+
+declare class TRPCError extends Error {
+  readonly cause?: Error;
+  readonly code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
+  constructor(opts: {
+    message?: string;
+    code: TRPC_ERROR_CODE_KEY;
+    cause?: unknown;
+  });
+}
+//# sourceMappingURL=TRPCError.d.ts.map
+//#endregion
+//#region src/vendor/standard-schema-v1/spec.d.ts
+/**
+ *
+ * @see https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
+ */
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input$1 = unknown, Output$1 = Input$1> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input$1, Output$1>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input$1 = unknown, Output$1 = Input$1> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output$1> | Promise<Result<Output$1>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input$1, Output$1> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output$1> = SuccessResult<Output$1> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output$1> {
+    /** The typed output value. */
+    readonly value: Output$1;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input$1 = unknown, Output$1 = Input$1> {
+    /** The input type of the schema. */
+    readonly input: Input$1;
+    /** The output type of the schema. */
+    readonly output: Output$1;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+//# sourceMappingURL=spec.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/parser.d.ts
+type ParserZodEsque<TInput, TParsedInput> = {
+  _input: TInput;
+  _output: TParsedInput;
+};
+type ParserValibotEsque<TInput, TParsedInput> = {
+  schema: {
+    _types?: {
+      input: TInput;
+      output: TParsedInput;
+    };
+  };
+};
+type ParserArkTypeEsque<TInput, TParsedInput> = {
+  inferIn: TInput;
+  infer: TParsedInput;
+};
+type ParserStandardSchemaEsque<TInput, TParsedInput> = StandardSchemaV1<TInput, TParsedInput>;
+type ParserMyZodEsque<TInput> = {
+  parse: (input: any) => TInput;
+};
+type ParserSuperstructEsque<TInput> = {
+  create: (input: unknown) => TInput;
+};
+type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
+type ParserYupEsque<TInput> = {
+  validateSync: (input: unknown) => TInput;
+};
+type ParserScaleEsque<TInput> = {
+  assert(value: unknown): asserts value is TInput;
+};
+type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
+type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput> | ParserArkTypeEsque<TInput, TParsedInput> | ParserStandardSchemaEsque<TInput, TParsedInput>;
+type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+/**
+ * @internal
+ */
+interface ProcedureCallOptions<TContext$1> {
+  ctx: TContext$1;
+  getRawInput: GetRawInputFn;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+  signal: AbortSignal | undefined;
+}
+//#endregion
+//#region src/unstable-core-do-not-import/procedure.d.ts
+declare const procedureTypes: readonly ["query", "mutation", "subscription"];
+/**
+ * @public
+ */
+type ProcedureType = (typeof procedureTypes)[number];
+interface BuiltProcedureDef {
+  meta: unknown;
+  input: unknown;
+  output: unknown;
+}
+/**
+ *
+ * @internal
+ */
+interface Procedure<TType extends ProcedureType, TDef extends BuiltProcedureDef> {
+  _def: {
+    /**
+     * These are just types, they can't be used at runtime
+     * @internal
+     */
+    $types: {
+      input: TDef['input'];
+      output: TDef['output'];
+    };
+    procedure: true;
+    type: TType;
+    /**
+     * @internal
+     * Meta is not inferrable on individual procedures, only on the router
+     */
+    meta: unknown;
+    experimental_caller: boolean;
+    /**
+     * The input parsers for the procedure
+     */
+    inputs: Parser[];
+  };
+  meta: TDef['meta'];
+  /**
+   * @internal
+   */
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
+}
+interface QueryProcedure<TDef extends BuiltProcedureDef> extends Procedure<'query', TDef> {}
+interface MutationProcedure<TDef extends BuiltProcedureDef> extends Procedure<'mutation', TDef> {}
+interface SubscriptionProcedure<TDef extends BuiltProcedureDef> extends Procedure<'subscription', TDef> {}
+/**
+ * @deprecated
+ */
+interface LegacyObservableSubscriptionProcedure<TDef extends BuiltProcedureDef> extends SubscriptionProcedure<TDef> {
+  _observable: true;
+}
+type AnyQueryProcedure = QueryProcedure<any>;
+type AnyMutationProcedure = MutationProcedure<any>;
+type AnySubscriptionProcedure = SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
+type AnyProcedure = AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
+type inferProcedureInput<TProcedure extends AnyProcedure> = undefined extends inferProcedureParams<TProcedure>['$types']['input'] ? void | inferProcedureParams<TProcedure>['$types']['input'] : inferProcedureParams<TProcedure>['$types']['input'];
+type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure ? TProcedure['_def'] : never;
+type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>['$types']['output'];
+/**
+ * @internal
+ */
+interface ErrorHandlerOptions<TContext$1> {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext$1 | undefined;
+}
+//#endregion
+//#region src/unstable-core-do-not-import/http/types.d.ts
+/**
+ * @deprecated use `Headers` instead, this will be removed in v12
+ */
+
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/envelopes.d.ts
+/**
+ * Error response
+ */
+interface TRPCErrorShape<TData extends object = object> {
+  code: TRPC_ERROR_CODE_NUMBER;
+  message: string;
+  data: TData;
+}
+/**
+ * JSON-RPC 2.0 Specification
+ */
+
+//# sourceMappingURL=envelopes.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/transformer.d.ts
+/**
+ * @public
+ */
+interface DataTransformer {
+  serialize(object: any): any;
+  deserialize(object: any): any;
+}
+interface InputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the client** before sending the data to the server.
+   */
+  serialize(object: any): any;
+  /**
+   * This function runs **on the server** to transform the data before it is passed to the resolver
+   */
+  deserialize(object: any): any;
+}
+interface OutputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the server** before sending the data to the client.
+   */
+  serialize(object: any): any;
+  /**
+   * This function runs **only on the client** to transform the data sent from the server.
+   */
+  deserialize(object: any): any;
+}
+/**
+ * @public
+ */
+interface CombinedDataTransformer {
+  /**
+   * Specify how the data sent from the client to the server should be transformed.
+   */
+  input: InputDataTransformer;
+  /**
+   * Specify how the data sent from the server to the client should be transformed.
+   */
+  output: OutputDataTransformer;
+}
+/**
+ * @public
+ */
+
+//# sourceMappingURL=parseTRPCMessage.d.ts.map
+
+//#endregion
+//#region src/unstable-core-do-not-import/error/formatter.d.ts
+/**
+ * @internal
+ */
+type ErrorFormatter<TContext$1, TShape extends TRPCErrorShape> = (opts: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext$1 | undefined;
+  shape: DefaultErrorShape;
+}) => TShape;
+/**
+ * @internal
+ */
+type DefaultErrorData = {
+  code: TRPC_ERROR_CODE_KEY;
+  httpStatus: number;
+  /**
+   * Path to the procedure that threw the error
+   */
+  path?: string;
+  /**
+   * Stack trace of the error (only in development)
+   */
+  stack?: string;
+};
+/**
+ * @internal
+ */
+interface DefaultErrorShape extends TRPCErrorShape<DefaultErrorData> {
+  message: string;
+  code: TRPC_ERROR_CODE_NUMBER;
+}
+type Serialize$2 = (value: any) => any;
+type PathArray = readonly (string | number)[];
+type ProducerOnError = (opts: {
+  error: unknown;
+  path: PathArray;
+}) => void;
+interface JSONLProducerOptions {
+  serialize?: Serialize$2;
+  data: Record<string, unknown> | unknown[];
+  onError?: ProducerOnError;
+  formatError?: (opts: {
+    error: unknown;
+    path: PathArray;
+  }) => unknown;
+  maxDepth?: number;
+  /**
+   * Interval in milliseconds to send a ping to the client to keep the connection alive
+   * This will be sent as a whitespace character
+   * @default undefined
+   */
+  pingMs?: number;
+}
+/**
+ * JSON Lines stream producer
+ * @see https://jsonlines.org/
+ */
+
+//# sourceMappingURL=sse.types.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/stream/sse.d.ts
+type Serialize$1 = (value: any) => any;
+/**
+ * @internal
+ */
+interface SSEPingOptions {
+  /**
+   * Enable ping comments sent from the server
+   * @default false
+   */
+  enabled: boolean;
+  /**
+   * Interval in milliseconds
+   * @default 1000
+   */
+  intervalMs?: number;
+}
+interface SSEClientOptions {
+  /**
+   * Timeout and reconnect after inactivity in milliseconds
+   * @default undefined
+   */
+  reconnectAfterInactivityMs?: number;
+}
+interface SSEStreamProducerOptions<TValue$1 = unknown> {
+  serialize?: Serialize$1;
+  data: AsyncIterable<TValue$1>;
+  maxDepth?: number;
+  ping?: SSEPingOptions;
+  /**
+   * Maximum duration in milliseconds for the request before ending the stream
+   * @default undefined
+   */
+  maxDurationMs?: number;
+  /**
+   * End the request immediately after data is sent
+   * Only useful for serverless runtimes that do not support streaming responses
+   * @default false
+   */
+  emitAndEndImmediately?: boolean;
+  formatError?: (opts: {
+    error: unknown;
+  }) => unknown;
+  /**
+   * Client-specific options - these will be sent to the client as part of the first message
+   * @default {}
+   */
+  client?: SSEClientOptions;
+}
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+
+//#endregion
+//#region src/unstable-core-do-not-import/rootConfig.d.ts
+/**
+ * The initial generics that are used in the init function
+ * @internal
+ */
+interface RootTypes {
+  ctx: object;
+  meta: object;
+  errorShape: DefaultErrorShape;
+  transformer: boolean;
+}
+/**
+ * The default check to see if we're in a server
+ */
+
+/**
+ * The tRPC root config
+ * @internal
+ */
+interface RootConfig<TTypes extends RootTypes> {
+  /**
+   * The types that are used in the config
+   * @internal
+   */
+  $types: TTypes;
+  /**
+   * Use a data transformer
+   * @see https://trpc.io/docs/v11/data-transformers
+   */
+  transformer: CombinedDataTransformer;
+  /**
+   * Use custom error formatting
+   * @see https://trpc.io/docs/v11/error-formatting
+   */
+  errorFormatter: ErrorFormatter<TTypes['ctx'], TTypes['errorShape']>;
+  /**
+   * Allow `@trpc/server` to run in non-server environments
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default false
+   */
+  allowOutsideOfServer: boolean;
+  /**
+   * Is this a server environment?
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
+   */
+  isServer: boolean;
+  /**
+   * Is this development?
+   * Will be used to decide if the API should return stack traces
+   * @default process.env.NODE_ENV !== 'production'
+   */
+  isDev: boolean;
+  defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
+  /**
+   * Options for server-sent events (SSE) subscriptions
+   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+   */
+  sse?: {
+    /**
+     * Enable server-sent events (SSE) subscriptions
+     * @default true
+     */
+    enabled?: boolean;
+  } & Pick<SSEStreamProducerOptions, 'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'>;
+  /**
+   * Options for batch stream
+   * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+   */
+  jsonl?: Pick<JSONLProducerOptions, 'pingMs'>;
+  experimental?: {};
+}
+/**
+ * @internal
+ */
+type CreateRootTypes<TGenerics extends RootTypes> = TGenerics;
+type AnyRootTypes = CreateRootTypes<{
+  ctx: any;
+  meta: any;
+  errorShape: any;
+  transformer: any;
+}>;
+//#endregion
+//#region src/unstable-core-do-not-import/router.d.ts
+interface RouterRecord {
+  [key: string]: AnyProcedure | RouterRecord;
+}
+type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedureInput<TProcedure>) => Promise<TProcedure['_def']['type'] extends 'subscription' ? TProcedure extends LegacyObservableSubscriptionProcedure<any> ? Observable<inferProcedureOutput<TProcedure>, TRPCError> : inferProcedureOutput<TProcedure> : inferProcedureOutput<TProcedure>>;
+/**
+ * @internal
+ */
+type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never };
+/**
+ * @internal
+ */
+type RouterCallerErrorHandler<TContext$1> = (opts: ErrorHandlerOptions<TContext$1>) => void;
+/**
+ * @internal
+ */
+type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
+/**
+ * @note
+ * If passing a function, we recommend it's a cached function
+ * e.g. wrapped in `React.cache` to avoid unnecessary computations
+ */
+ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>), options?: {
+  onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+  signal?: AbortSignal;
+}) => DecorateRouterRecord<TRecord>;
+type Lazy<TAny> = (() => Promise<TAny>) & {};
+type LazyLoader<TAny> = {
+  load: () => Promise<void>;
+  ref: Lazy<TAny>;
+};
+/**
+ * Lazy load a router
+ * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ */
+
+/**
+ * @internal
+ */
+interface RouterDef<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _config: RootConfig<TRoot>;
+  router: true;
+  procedure?: never;
+  procedures: TRecord;
+  record: TRecord;
+  lazy: Record<string, LazyLoader<AnyRouter>>;
+}
+interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _def: RouterDef<TRoot, TRecord>;
+  /**
+   * @see https://trpc.io/docs/v11/server/server-side-calls
+   */
+  createCaller: RouterCaller<TRoot, TRecord>;
+}
+type AnyRouter = Router<any, any>;
+//#endregion
 //#region src/transport.d.ts
 /**
  * Normalized representation of args passed to a transport.
@@ -77,6 +672,9 @@ declare class Store {
 type ResolvedArgsPayload = AnyRecord;
 type TransportMutations = Record<string, MutationShape>;
 type EmptyTransportMutations = Record<never, MutationShape>;
+type Bivariant<Fn extends (...args: Array<any>) => any> = {
+  bivarianceHack: Fn;
+}['bivarianceHack'];
 /**
  * Contract the fate client expects from a network transport. The transport is
  * responsible for fetching records by ID, fetching lists, and executing
@@ -105,16 +703,13 @@ type TRPCByIdResolvers<AppRouter extends AnyRouter> = Record<string, (client: TR
 /**
  * Mapping of list procedure name to a tRPC resolver factory.
  */
-type TRPCListResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => (input: {
-  args?: ResolvedArgsPayload;
-  select: Array<string>;
-}) => Promise<{
+type TRPCListResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => Bivariant<(input: any) => Promise<{
   items: Array<{
     cursor: string | undefined;
     node: unknown;
   }>;
   pagination: Pagination;
-}>>;
+}>>>;
 /**
  * Mapping of query procedure name to a tRPC resolver factory.
  */
@@ -181,8 +776,10 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   private readonly parentLists;
   private readonly rootLists;
   private readonly pending;
+  private readonly pendingOptimisticMutations;
   private readonly optimisticMasks;
   private readonly optimisticByEntity;
+  private readonly optimisticEntityResolutions;
   private optimisticTokenCounter;
   private readonly requests;
   private readonly rootRequests;
@@ -215,11 +812,14 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   }>;
   readView<T$1 extends Entity, S extends Selection<T$1>, V extends View<T$1, S>>(view: V, ref: ViewRef<T$1['__typename']>): FateThenable<ViewSnapshot<T$1, S>>;
   private mergeListState;
+  registerPendingOptimisticMutation(entityId: EntityId, promise: Promise<unknown>): void;
+  resolveOptimisticEntity(optimisticEntityId: EntityId, resolvedEntityId: EntityId): void;
   registerOptimisticUpdate(entityId: EntityId | null, select: ReadonlySet<string>): number | null;
   clearOptimisticUpdate(token: number | null): void;
   getPendingOptimisticMask(entityId: EntityId | null, options?: {
     excludeToken?: number | null;
   }): FieldMask | null;
+  private getPendingOptimisticMutations;
   filterSelectionForPendingOptimistics(entityId: EntityId | null, select: Set<string>, options?: {
     excludeToken?: number | null;
   }): Set<string>;
@@ -230,13 +830,13 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
     ids: ReadonlyArray<EntityId>;
     pagination?: Pagination;
   }> | undefined>;
-  request<R$1 extends Request>(request: R$1, options?: RequestOptions): Promise<RequestResult<Roots, R$1>>;
-  releaseRequest(request: Request, mode: RequestMode): void;
+  request<R$1 extends Request$1>(request: R$1, options?: RequestOptions): Promise<RequestResult<Roots, R$1>>;
+  releaseRequest(request: Request$1, mode: RequestMode): void;
   private handleStoreAndNetworkRequest;
   private getRootType;
   private executeRequest;
   private hasRequestData;
-  getRequestResult<R$1 extends Request>(request: R$1): RequestResult<Roots, R$1>;
+  getRequestResult<R$1 extends Request$1>(request: R$1): RequestResult<Roots, R$1>;
   private fetchByIdAndNormalize;
   private fetchQueryAndNormalize;
   private fetchListAndNormalize;
@@ -523,7 +1123,7 @@ type NodesItem<V extends View<any, any>> = Readonly<{
 }>;
 type RequestItem = ListItem<View<any, any>> | NodeItem<View<any, any>> | NodesItem<View<any, any>> | QueryItem<View<any, any>>;
 /** Collection of node and list requests describing the data a screen needs. */
-type Request = Record<string, RequestItem>;
+type Request$1 = Record<string, RequestItem>;
 type AnyView = View<any, any>;
 type AnyListItem = ListItem<AnyView>;
 type AnyQueryItem = QueryItem<AnyView>;
@@ -540,7 +1140,7 @@ type ConnectionNodeType<Root> = Root extends {
     node?: infer Node;
   };
 } ? ViewEntityName<Node & View<any, any>> : never;
-type ListResult<Item extends AnyRequestItem, Type extends TypeName, Result> = Item extends AnyNodeItem ? ViewRef<Type> : Item extends AnyNodesItem ? Array<ViewRef<Type>> : Item extends AnyQueryItem ? Result extends null ? ViewRef<Type> | null : ViewRef<Type> : Item extends AnyListItem ? Item['list'] extends {
+type ListResult<Item extends AnyRequestItem, Type extends TypeName, Result$1> = Item extends AnyNodeItem ? ViewRef<Type> : Item extends AnyNodesItem ? Array<ViewRef<Type>> : Item extends AnyQueryItem ? Result$1 extends null ? ViewRef<Type> | null : ViewRef<Type> : Item extends AnyListItem ? Item['list'] extends {
   items?: {
     node?: View<any, any>;
   };
@@ -561,10 +1161,10 @@ declare const RootKind = "__fate__root";
 /** Brand used on mutation definitions to mark their identity in the d.ts output. */
 declare const MutationKind = "__fate__mutation";
 /** Metadata describing a root query for a particular entity and result shape. */
-type RootDefinition<Type extends TypeName, Result> = Readonly<{
+type RootDefinition<Type extends TypeName, Result$1> = Readonly<{
   [RootKind]: true;
   type: Type;
-}> & __RootResultAnchor<Result> & __RootTypeAnchor<Type>;
+}> & __RootResultAnchor<Result$1> & __RootTypeAnchor<Type>;
 /** Minimal root description used for typing root maps. */
 type FateRoots = Record<string, RootDefinition<TypeName, unknown>>;
 /** Extracts the entity type name from a root definition. */
@@ -612,4 +1212,4 @@ interface FateThenable<T$1> extends PromiseLike<T$1> {
   value: T$1;
 }
 //#endregion
-export { ViewSelection as A, RequestOptions as B, TypeConfig as C, ViewEntity as D, ViewData as E, isViewTag as F, Transport as H, FateMutations as I, mutation as L, ViewTag as M, __FateEntityBrand as N, ViewEntityName as O, __FateSelectionBrand as P, FateClient as R, Snapshot as S, View as T, createTRPCTransport as U, createClient as V, getSelectionPlan as W, Pagination as _, Entity as a, RootDefinition as b, FateThenable as c, MutationDefinition as d, MutationEntity as f, NodesItem as g, MutationResult as h, ConnectionTag as i, ViewSnapshot as j, ViewRef as k, ListItem as l, MutationInput as m, ConnectionMetadata as n, EntityId as o, MutationIdentifier as p, ConnectionRef as r, FateRoots as s, AnyRecord as t, Mask as u, Request as v, TypeName as w, Selection as x, RequestResult as y, RequestMode as z };
+export { ViewSelection as A, RequestOptions as B, TypeConfig as C, ViewEntity as D, ViewData as E, isViewTag as F, getSelectionPlan as G, Transport as H, FateMutations as I, mutation as L, ViewTag as M, __FateEntityBrand as N, ViewEntityName as O, __FateSelectionBrand as P, FateClient as R, Snapshot as S, View as T, createTRPCTransport as U, createClient as V, QueryProcedure as W, Pagination as _, Entity as a, RootDefinition as b, FateThenable as c, MutationDefinition as d, MutationEntity as f, NodesItem as g, MutationResult as h, ConnectionTag as i, ViewSnapshot as j, ViewRef as k, ListItem as l, MutationInput as m, ConnectionMetadata as n, EntityId as o, MutationIdentifier as p, ConnectionRef as r, FateRoots as s, AnyRecord as t, Mask as u, Request$1 as v, TypeName as w, Selection as x, RequestResult as y, RequestMode as z };

package/package.json

@@ -1,47 +1,50 @@
 {
   "name": "@nkzw/fate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "fate is a modern data client for React.",
   "homepage": "https://github.com/nkzw-tech/fate",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/nkzw-tech/fate"
-  },
   "license": "MIT",
   "author": {
     "name": "Christoph Nakazawa",
     "email": "christoph.pojer@gmail.com"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nkzw-tech/fate"
+  },
+  "bin": {
+    "fate": "./lib/cli.mjs"
+  },
+  "files": [
+    "lib"
+  ],
   "type": "module",
+  "main": "./lib/index.mjs",
+  "types": "./lib/index.d.mts",
   "exports": {
     ".": {
       "types": "./lib/index.d.mts",
+      "@nkzw/source": "./src/index.ts",
       "default": "./lib/index.mjs"
     },
     "./cli": {
       "types": "./lib/cli.d.mts",
+      "@nkzw/source": "./src/cli.ts",
       "default": "./lib/cli.mjs"
     },
     "./server": {
       "types": "./lib/server.d.mts",
+      "@nkzw/source": "./src/server.ts",
       "default": "./lib/server.mjs"
     }
   },
-  "main": "./lib/index.mjs",
-  "types": "./lib/index.d.mts",
-  "bin": {
-    "fate": "./lib/cli.mjs"
-  },
-  "files": [
-    "lib"
-  ],
   "dependencies": {
     "superjson": "^2.2.6",
-    "zod": "^4.1.13"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@trpc/client": "^11.7.2",
-    "@trpc/server": "^11.7.2"
+    "@trpc/client": "^11.8.1",
+    "@trpc/server": "^11.8.1"
   },
   "peerDependencies": {
     "@trpc/client": "^11.6.0"