@nkzw/fate 1.0.3 → 1.1.0

package/lib/graphqlTransport-DbRHbYtb.d.mts

@@ -0,0 +1,74 @@
+import { E as TypeConfig, s as Entity, t as Transport, v as MutationShape } from "./transport-BTgtSwOM.mjs";
+
+//#region src/graphqlTransport.d.ts
+type TransportMutations = Record<string, MutationShape>;
+type EmptyTransportMutations = Record<never, MutationShape>;
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type HeadersFactory = HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+type EventSourceConstructor = new (url: string, options?: {
+  withCredentials?: boolean;
+}) => {
+  addEventListener(type: string, listener: (event: Event) => void): void;
+  close(): void;
+  removeEventListener(type: string, listener: (event: Event) => void): void;
+};
+type GraphQLRootConfig = {
+  connection?: 'relay';
+  field?: string;
+  type: string;
+};
+type GraphQLMutationDefinition<T extends Entity = Entity, Input = unknown, Output = unknown> = Readonly<{
+  __fateGraphQLMutation?: {
+    input: Input;
+    output: Output;
+  };
+  entity: T['__typename'];
+  field: string;
+  inputArg?: false | string;
+}>;
+type GraphQLMutationInput<Definition> = Definition extends GraphQLMutationDefinition<any, infer Input, any> ? Input : never;
+type GraphQLMutationOutput<Definition> = Definition extends GraphQLMutationDefinition<any, any, infer Output> ? Output : never;
+type GraphQLMutationMap<Mutations> = Mutations extends Record<string, GraphQLMutationDefinition> ? { [K in keyof Mutations]: {
+  input: GraphQLMutationInput<Mutations[K]>;
+  output: GraphQLMutationOutput<Mutations[K]>;
+} } : EmptyTransportMutations;
+type GraphQLMutationRuntimeConfig = {
+  entity: string;
+  field: string;
+  inputArg?: false | string;
+};
+type GraphQLLiveOptions = {
+  connectionField?: string;
+  entityField?: string;
+  url?: string | URL;
+  withCredentials?: boolean;
+};
+type GraphQLTransportOptions<Mutations extends TransportMutations = EmptyTransportMutations> = {
+  decodeNodeId?: (type: string, id: string | number) => string | number;
+  encodeNodeId?: (type: string, id: string | number) => string | number;
+  eventSource?: EventSourceConstructor;
+  fetch?: FetchLike;
+  headers?: HeadersFactory;
+  live?: boolean | GraphQLLiveOptions;
+  mutations?: Record<Extract<keyof Mutations, string>, GraphQLMutationRuntimeConfig>;
+  roots?: Record<string, GraphQLRootConfig>;
+  types: ReadonlyArray<Omit<TypeConfig, 'getId'> & Partial<Pick<TypeConfig, 'getId'>>>;
+  url: string | URL;
+};
+declare function graphqlMutation<T extends Entity, Input, Output>(entity: T['__typename'], options: {
+  field: string;
+  inputArg?: false | string;
+}): GraphQLMutationDefinition<T, Input, Output>;
+declare function createGraphQLTransport<Mutations extends TransportMutations = EmptyTransportMutations>({
+  decodeNodeId,
+  encodeNodeId,
+  fetch: fetchImpl,
+  headers,
+  live,
+  mutations,
+  roots,
+  types: typeConfigs,
+  url
+}: GraphQLTransportOptions<Mutations>): Transport<Mutations>;
+//#endregion
+export { GraphQLTransportOptions as a, GraphQLMutationOutput as i, GraphQLMutationInput as n, createGraphQLTransport as o, GraphQLMutationMap as r, graphqlMutation as s, GraphQLMutationDefinition as t };

package/lib/graphqlTransport-IFgmY-Qq.mjs

@@ -0,0 +1,499 @@
+import { t as isRecord } from "./record-B07VwXd-.mjs";
+//#region src/graphqlTransport.ts
+const defaultFetch = (input, init) => globalThis.fetch(input, init);
+const importGraphQLSSE = () => import("graphql-sse");
+const normalizeEndpoint = (url) => String(url).replace(/\/$/, "");
+const resolveHeaders = async (headers) => typeof headers === "function" ? await headers() : headers ?? {};
+const requestHeaders = async (defaults, headers) => {
+	const result = new Headers(defaults);
+	new Headers(await resolveHeaders(headers)).forEach((value, key) => {
+		result.set(key, value);
+	});
+	return result;
+};
+const headersToRecord = (headers) => {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+};
+const assertIdentifier = (value, context) => {
+	if (!/^[_A-Za-z][_0-9A-Za-z]*$/.test(value)) throw new Error(`fate(graphql): Invalid GraphQL ${context} '${value}'.`);
+	return value;
+};
+const defaultEncodeNodeId = (type, id) => `${type}-${id}`;
+const defaultDecodeNodeId = (type, id) => {
+	if (typeof id !== "string") return id;
+	const prefix = `${type}-`;
+	return id.startsWith(prefix) ? id.slice(prefix.length) : id;
+};
+const errorCodeFromGraphQL = (error) => {
+	const code = error?.extensions?.code;
+	return typeof code === "string" ? code : "INTERNAL_ERROR";
+};
+const responseError = async (response) => {
+	let message = response.statusText || `HTTP ${response.status}`;
+	try {
+		const payload = await response.clone().json();
+		if (payload.errors?.[0]?.message) message = payload.errors[0].message;
+	} catch {
+		try {
+			const text = await response.text();
+			if (text) message = text;
+		} catch {}
+	}
+	return new Error(message);
+};
+const assertGraphQLResponse = (value) => {
+	if (!isRecord(value)) throw new Error("fate(graphql): Invalid GraphQL response.");
+	return value;
+};
+const graphQLLiteral = (value) => {
+	if (value === null) return "null";
+	const type = typeof value;
+	if (type === "string") return JSON.stringify(value);
+	if (type === "number" || type === "boolean") return String(value);
+	if (Array.isArray(value)) return `[${value.map(graphQLLiteral).join(", ")}]`;
+	if (isRecord(value)) return `{ ${Object.entries(value).map(([key, entry]) => `${assertIdentifier(key, "argument")}: ${graphQLLiteral(entry)}`).join(", ")} }`;
+	if (value === void 0) return "null";
+	throw new Error(`fate(graphql): Cannot serialize GraphQL argument of type '${type}'.`);
+};
+const argsToGraphQL = (args) => {
+	const entries = args ? Object.entries(args).filter(([, value]) => value !== void 0) : [];
+	if (entries.length === 0) return "";
+	return `(${entries.map(([key, value]) => `${assertIdentifier(key, "argument")}: ${graphQLLiteral(value)}`).join(", ")})`;
+};
+const getArgsAtPath = (args, path) => {
+	if (!args) return;
+	if (!path) return args;
+	let current = args;
+	for (const segment of path.split(".")) {
+		if (!isRecord(current)) return;
+		current = current[segment];
+	}
+	return isRecord(current) ? current : void 0;
+};
+const getTypeConfig = (types, type) => {
+	const config = types.get(type);
+	if (!config) throw new Error(`fate(graphql): Unknown entity type '${type}'.`);
+	return config;
+};
+const rootArgsToGraphQL = ({ args, type, types }) => {
+	if (!args) return "";
+	const fields = getTypeConfig(types, type).fields ?? {};
+	return argsToGraphQL(Object.fromEntries(Object.entries(args).filter(([key]) => {
+		const descriptor = fields[key];
+		return !(descriptor && typeof descriptor === "object" && ("listOf" in descriptor || "type" in descriptor));
+	})));
+};
+const buildSelectionTree = (select) => {
+	const root = /* @__PURE__ */ new Map();
+	for (const path of select) {
+		let current = root;
+		for (const segment of path.split(".")) {
+			if (!segment) continue;
+			let next = current.get(segment);
+			if (!next) {
+				next = /* @__PURE__ */ new Map();
+				current.set(segment, next);
+			}
+			current = next;
+		}
+	}
+	return root;
+};
+const buildRecordSelection = ({ args, path, select, type, types }) => {
+	const tree = buildSelectionTree(select);
+	const walk = (currentType, currentTree, currentPath) => {
+		const config = getTypeConfig(types, currentType);
+		const fields = new Set([
+			...currentTree.keys(),
+			"id",
+			"__typename"
+		]);
+		const lines = [];
+		for (const field of [...fields].sort()) {
+			if (field === "__typename") {
+				lines.push("__typename");
+				continue;
+			}
+			const childTree = currentTree.get(field) ?? /* @__PURE__ */ new Map();
+			const descriptor = config.fields?.[field];
+			const fieldPath = currentPath ? `${currentPath}.${field}` : field;
+			const fieldName = assertIdentifier(field, "field");
+			if (descriptor && typeof descriptor === "object" && "type" in descriptor) {
+				lines.push(`${fieldName}${argsToGraphQL(getArgsAtPath(args, fieldPath))} { ${walk(descriptor.type, childTree, fieldPath)} }`);
+				continue;
+			}
+			if (descriptor && typeof descriptor === "object" && "listOf" in descriptor) {
+				lines.push(`${fieldName}${argsToGraphQL(getArgsAtPath(args, fieldPath))} { edges { cursor node { ${walk(descriptor.listOf, childTree, fieldPath)} } } pageInfo { endCursor hasNextPage hasPreviousPage startCursor } }`);
+				continue;
+			}
+			lines.push(fieldName);
+		}
+		return lines.join(" ");
+	};
+	return walk(type, tree, path);
+};
+const relayToFateConnection = (value) => {
+	if (!isRecord(value) || !Array.isArray(value.edges)) return value;
+	const pageInfo = isRecord(value.pageInfo) ? value.pageInfo : {};
+	return {
+		items: value.edges.flatMap((edge) => isRecord(edge) ? [{
+			cursor: typeof edge.cursor === "string" ? edge.cursor : void 0,
+			node: edge.node
+		}] : []),
+		pagination: {
+			hasNext: pageInfo.hasNextPage === true,
+			hasPrevious: pageInfo.hasPreviousPage === true,
+			nextCursor: typeof pageInfo.endCursor === "string" ? pageInfo.endCursor : void 0,
+			previousCursor: typeof pageInfo.startCursor === "string" ? pageInfo.startCursor : void 0
+		}
+	};
+};
+const normalizeGraphQLValue = ({ decodeNodeId, type, types, value }) => {
+	if (Array.isArray(value)) return value.map((entry) => normalizeGraphQLValue({
+		decodeNodeId,
+		types,
+		value: entry
+	}));
+	const connection = relayToFateConnection(value);
+	if (connection !== value) {
+		const connectionRecord = connection;
+		return {
+			...connectionRecord,
+			items: connectionRecord.items.map((entry) => ({
+				...entry,
+				node: normalizeGraphQLValue({
+					decodeNodeId,
+					types,
+					value: entry.node
+				})
+			}))
+		};
+	}
+	if (!isRecord(value)) return value;
+	const typename = typeof value.__typename === "string" ? value.__typename : type;
+	const config = typename ? types.get(typename) : void 0;
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (key === "id" && typename && (typeof entry === "string" || typeof entry === "number")) {
+			result.id = decodeNodeId(typename, entry);
+			continue;
+		}
+		const descriptor = config?.fields?.[key];
+		if (descriptor && typeof descriptor === "object" && "type" in descriptor) {
+			result[key] = normalizeGraphQLValue({
+				decodeNodeId,
+				type: descriptor.type,
+				types,
+				value: entry
+			});
+			continue;
+		}
+		result[key] = normalizeGraphQLValue({
+			decodeNodeId,
+			types,
+			value: entry
+		});
+	}
+	return result;
+};
+const graphQLRequest = async ({ fetchImpl, headers, query, url }) => {
+	const response = await fetchImpl(url, {
+		body: JSON.stringify({ query }),
+		headers: await requestHeaders({ "content-type": "application/json" }, headers),
+		method: "POST"
+	});
+	if (!response.ok) throw await responseError(response);
+	const payload = assertGraphQLResponse(await response.json());
+	return {
+		data: isRecord(payload.data) ? payload.data : {},
+		errors: payload.errors ?? []
+	};
+};
+const graphQLError = (error) => {
+	const code = errorCodeFromGraphQL(error);
+	return new Error(error?.message ?? `GraphQL ${code}`);
+};
+const reportExecutionError = (result, handlers) => {
+	if (!result?.errors?.length) return false;
+	handlers.onError?.(new Error(result.errors[0]?.message ?? "GraphQL subscription error."));
+	return true;
+};
+function graphqlMutation(entity, options) {
+	return Object.freeze({
+		entity,
+		field: options.field,
+		inputArg: options.inputArg
+	});
+}
+function createGraphQLTransport({ decodeNodeId = defaultDecodeNodeId, encodeNodeId = defaultEncodeNodeId, fetch: fetchImpl = defaultFetch, headers, live = true, mutations, roots, types: typeConfigs, url }) {
+	const endpoint = normalizeEndpoint(url);
+	const types = new Map(typeConfigs.map((type) => [type.type, type]));
+	let nextId = 0;
+	let pending = [];
+	let scheduled = false;
+	let graphQLLiveClient;
+	let graphQLSSEModule;
+	const enqueue = (operation) => new Promise((resolve, reject) => {
+		pending.push({
+			...operation,
+			alias: `f${++nextId}`,
+			reject,
+			resolve
+		});
+		if (!scheduled) {
+			scheduled = true;
+			queueMicrotask(flush);
+		}
+	});
+	const flush = async () => {
+		scheduled = false;
+		const batch = pending;
+		pending = [];
+		if (!batch.length) return;
+		await Promise.all(["query", "mutation"].map(async (kind) => {
+			const operations = batch.filter((entry) => entry.kind === kind);
+			if (operations.length === 0) return;
+			try {
+				const { data, errors } = await graphQLRequest({
+					fetchImpl,
+					headers,
+					query: `${kind} Fate${kind === "query" ? "Query" : "Mutation"} { ${operations.map((entry) => `${entry.alias}: ${entry.selection}`).join(" ")} }`,
+					url: endpoint
+				});
+				const aliases = new Set(operations.map((operation) => operation.alias));
+				const errorsByAlias = /* @__PURE__ */ new Map();
+				const globalErrors = [];
+				for (const error of errors) {
+					const alias = typeof error.path?.[0] === "string" ? error.path[0] : void 0;
+					if (alias && aliases.has(alias)) {
+						const aliasErrors = errorsByAlias.get(alias) ?? [];
+						aliasErrors.push(error);
+						errorsByAlias.set(alias, aliasErrors);
+					} else globalErrors.push(error);
+				}
+				if (globalErrors.length) throw graphQLError(globalErrors[0]);
+				for (const operation of operations) {
+					const operationErrors = errorsByAlias.get(operation.alias);
+					if (operationErrors?.length) {
+						operation.reject(graphQLError(operationErrors[0]));
+						continue;
+					}
+					operation.resolve(operation.transform(data[operation.alias]));
+				}
+			} catch (error) {
+				for (const operation of operations) operation.reject(error);
+			}
+		}));
+	};
+	const transport = {
+		fetchById(type, ids, select, args) {
+			const globalIds = ids.map((id) => encodeNodeId(type, id));
+			const selection = buildRecordSelection({
+				args,
+				path: "",
+				select,
+				type,
+				types
+			});
+			return enqueue({
+				kind: "query",
+				selection: `nodes(ids: ${graphQLLiteral(globalIds)}) { ... on ${assertIdentifier(type, "type")} { ${selection} } }`,
+				transform: (value) => (Array.isArray(value) ? value : []).filter(Boolean).map((entry) => normalizeGraphQLValue({
+					decodeNodeId,
+					type,
+					types,
+					value: entry
+				}))
+			});
+		},
+		fetchList(name, select, args) {
+			const root = roots?.[name];
+			if (!root) throw new Error(`fate(graphql): Missing root list mapping for '${name}'.`);
+			const field = assertIdentifier(root.field ?? name, "field");
+			const selection = buildRecordSelection({
+				args,
+				path: "",
+				select,
+				type: root.type,
+				types
+			});
+			return enqueue({
+				kind: "query",
+				selection: `${field}${rootArgsToGraphQL({
+					args,
+					type: root.type,
+					types
+				})} { edges { cursor node { ${selection} } } pageInfo { endCursor hasNextPage hasPreviousPage startCursor } }`,
+				transform: (value) => normalizeGraphQLValue({
+					decodeNodeId,
+					type: root.type,
+					types,
+					value
+				})
+			});
+		},
+		fetchQuery(name, select, args) {
+			const root = roots?.[name];
+			if (!root) throw new Error(`fate(graphql): Missing root query mapping for '${name}'.`);
+			const field = assertIdentifier(root.field ?? name, "field");
+			const selection = buildRecordSelection({
+				args,
+				path: "",
+				select,
+				type: root.type,
+				types
+			});
+			return enqueue({
+				kind: "query",
+				selection: `${field}${rootArgsToGraphQL({
+					args,
+					type: root.type,
+					types
+				})} { ${selection} }`,
+				transform: (value) => normalizeGraphQLValue({
+					decodeNodeId,
+					type: root.type,
+					types,
+					value
+				})
+			});
+		},
+		mutate(name, input, select) {
+			const mutation = mutations?.[name];
+			if (!mutation) throw new Error(`fate(graphql): Missing mutation mapping for '${name}'.`);
+			const field = assertIdentifier(mutation.field, "mutation");
+			const args = mutation.inputArg === false ? input ?? {} : { [mutation.inputArg ?? "input"]: input };
+			const selection = buildRecordSelection({
+				args: isRecord(input) && isRecord(input.args) ? input.args : void 0,
+				path: "",
+				select,
+				type: mutation.entity,
+				types
+			});
+			return enqueue({
+				kind: "mutation",
+				selection: `${field}${argsToGraphQL(args)} { ${selection} }`,
+				transform: (value) => normalizeGraphQLValue({
+					decodeNodeId,
+					type: mutation.entity,
+					types,
+					value
+				})
+			});
+		}
+	};
+	if (live !== false) {
+		const liveOptions = typeof live === "object" ? live : {};
+		const liveUrl = liveOptions.url ?? `${endpoint}/stream`;
+		const getLiveClient = async () => {
+			if (graphQLLiveClient) return graphQLLiveClient;
+			let graphQLSSE;
+			try {
+				graphQLSSE = await (graphQLSSEModule ??= importGraphQLSSE());
+			} catch (error) {
+				throw new Error("fate(graphql): GraphQL live queries require the optional 'graphql-sse' package. Install it or pass live: false.", { cause: error });
+			}
+			const { createClient } = graphQLSSE;
+			return graphQLLiveClient ??= createClient({
+				credentials: liveOptions.withCredentials === false ? "same-origin" : "include",
+				fetchFn: fetchImpl,
+				headers: async () => headersToRecord(await requestHeaders({}, headers)),
+				lazy: true,
+				singleConnection: true,
+				url: String(liveUrl)
+			});
+		};
+		const subscribeLive = (query, sink) => {
+			let disposed = false;
+			let unsubscribe;
+			getLiveClient().then((client) => {
+				if (disposed) return;
+				unsubscribe = client.subscribe({ query }, sink);
+				if (disposed) unsubscribe();
+			}).catch((error) => {
+				if (!disposed) sink.error(error);
+			});
+			return () => {
+				disposed = true;
+				unsubscribe?.();
+			};
+		};
+		transport.subscribeById = (type, id, select, args, handlers) => {
+			const field = assertIdentifier(liveOptions.entityField ?? "fateLiveNode", "subscription");
+			return subscribeLive(`subscription FateLiveNode { ${field}(type: ${graphQLLiteral(type)}, id: ${graphQLLiteral(encodeNodeId(type, id))}, select: ${graphQLLiteral([...select])}, args: ${graphQLLiteral(args ?? null)}) { data delete id select } }`, {
+				complete() {},
+				error: (error) => handlers.onError?.(error),
+				next(result) {
+					try {
+						if (reportExecutionError(result, handlers)) return;
+						const value = result.data?.[field];
+						if (!isRecord(value)) return;
+						const eventPayload = value;
+						if (eventPayload.delete) {
+							handlers.onDelete?.(eventPayload.id == null ? id : decodeNodeId(type, eventPayload.id));
+							return;
+						}
+						handlers.onData(normalizeGraphQLValue({
+							decodeNodeId,
+							type,
+							types,
+							value: eventPayload.data
+						}), eventPayload.select);
+					} catch (error) {
+						handlers.onError?.(error);
+					}
+				}
+			});
+		};
+		transport.subscribeConnection = (procedure, type, args, select, selectionArgs, handlers) => {
+			const field = assertIdentifier(liveOptions.connectionField ?? "fateLiveConnection", "subscription");
+			return subscribeLive(`subscription FateLiveConnection { ${field}(procedure: ${graphQLLiteral(procedure)}, type: ${graphQLLiteral(type)}, args: ${graphQLLiteral(args ?? null)}, select: ${graphQLLiteral([...select])}, selectionArgs: ${graphQLLiteral(selectionArgs ?? null)}) { cursor id node nodeType targetCursor type } }`, {
+				complete() {},
+				error: (error) => handlers.onError?.(error),
+				next(result) {
+					try {
+						if (reportExecutionError(result, handlers)) return;
+						const value = result.data?.[field];
+						if (!isRecord(value)) return;
+						const eventPayload = value;
+						if (eventPayload.type === "invalidate") {
+							handlers.onEvent({ type: "invalidate" });
+							return;
+						}
+						if (eventPayload.type === "deleteEdge") {
+							if (eventPayload.id != null) handlers.onEvent({
+								id: decodeNodeId(eventPayload.nodeType ?? type, eventPayload.id),
+								nodeType: eventPayload.nodeType ?? type,
+								type: "deleteEdge"
+							});
+							return;
+						}
+						handlers.onEvent({
+							edge: {
+								cursor: eventPayload.cursor,
+								node: normalizeGraphQLValue({
+									decodeNodeId,
+									type: eventPayload.nodeType ?? type,
+									types,
+									value: eventPayload.node
+								})
+							},
+							nodeType: eventPayload.nodeType ?? type,
+							targetCursor: eventPayload.targetCursor,
+							type: eventPayload.type
+						});
+					} catch (error) {
+						handlers.onError?.(error);
+					}
+				}
+			});
+		};
+	}
+	return transport;
+}
+//#endregion
+export { graphqlMutation as n, createGraphQLTransport as t };

package/lib/graphqlTransport.d.mts

@@ -0,0 +1,2 @@
+import { a as GraphQLTransportOptions, i as GraphQLMutationOutput, n as GraphQLMutationInput, o as createGraphQLTransport, r as GraphQLMutationMap, s as graphqlMutation, t as GraphQLMutationDefinition } from "./graphqlTransport-DbRHbYtb.mjs";
+export { GraphQLMutationDefinition, GraphQLMutationInput, GraphQLMutationMap, GraphQLMutationOutput, GraphQLTransportOptions, createGraphQLTransport, graphqlMutation };

package/lib/graphqlTransport.mjs

@@ -0,0 +1,2 @@
+import { n as graphqlMutation, t as createGraphQLTransport } from "./graphqlTransport-IFgmY-Qq.mjs";
+export { createGraphQLTransport, graphqlMutation };

package/lib/index.d.mts

@@ -1,6 +1,7 @@
-import { A as ViewRef, B as RequestMode, C as Snapshot, D as ViewData, E as View, F as __FateSelectionBrand, G as createTRPCTransport, H as createClient, I as isViewTag, J as getSelectionPlan, L as FateMutations, M as ViewSnapshot, N as ViewTag, O as ViewEntity, P as __FateEntityBrand, R as mutation, S as Selection, T as TypeName, U as List, V as RequestOptions, W as Transport, _ as NodesItem, a as Entity, b as RequestResult, c as FateThenable, d as MutationDefinition, f as MutationEntity, g as MutationShape, h as MutationResult, i as ConnectionTag, j as ViewSelection, k as ViewEntityName, 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 Pagination, w as TypeConfig, x as RootDefinition, y as Request$1, z as FateClient } from "./types-Dz46PXr3.mjs";
-import { C as liveGlobalConnectionTopic, S as liveEntityTopic, a as FateProtocolRequest, i as FateOperation, n as FateLiveConnectionEvent, o as FateProtocolResponse, r as FateLiveEvent, t as isRecord, u as InferFateAPI, x as liveConnectionTopic } from "./record-CirbfZWX.mjs";
-import { n as getListEntries, t as ListEntry } from "./list-4wRNSVgI.mjs";
+import { A as ViewEntity, B as mutation, C as RootDefinition, D as TypeName, E as TypeConfig, F as ViewTag, G as getSelectionPlan, H as RequestMode, I as __FateEntityBrand, J as HydrationLimits, K as FateDehydratedState, L as __FateSelectionBrand, M as ViewRef, N as ViewSelection, O as View, P as ViewSnapshot, R as isViewTag, S as RequestResult, T as Snapshot, U as RequestOptions, V as FateClient, W as createClient, Y as List, _ as MutationResult, a as ConnectionRef, b as Pagination, c as EntityId, d as ListItem, f as Mask, g as MutationInput, h as MutationIdentifier, i as ConnectionMetadata, j as ViewEntityName, k as ViewData, l as FateRoots, m as MutationEntity, n as createTRPCTransport, o as ConnectionTag, p as MutationDefinition, q as HydrateOptions, r as AnyRecord, s as Entity, t as Transport, u as FateThenable, v as MutationShape, w as Selection, x as Request$1, y as NodesItem, z as FateMutations } from "./transport-BTgtSwOM.mjs";
+import { a as GraphQLTransportOptions, i as GraphQLMutationOutput, n as GraphQLMutationInput, o as createGraphQLTransport, r as GraphQLMutationMap, s as graphqlMutation, t as GraphQLMutationDefinition } from "./graphqlTransport-DbRHbYtb.mjs";
+import { C as liveGlobalConnectionTopic, S as liveEntityTopic, a as FateProtocolRequest, i as FateOperation, n as FateLiveConnectionEvent, o as FateProtocolResponse, r as FateLiveEvent, t as isRecord, u as InferFateAPI, x as liveConnectionTopic } from "./record-BtdKzEGI.mjs";
+import { n as getListEntries, t as ListEntry } from "./list-CMQOQGdn.mjs";
 
 //#region src/httpTransport.d.ts
 type TransportMutations = Record<string, MutationShape>;
@@ -87,4 +88,4 @@ type SelectionValidation<T extends Entity, S extends Selection<T>> = Exclude<key
  */
 declare function view<T extends Entity>(): <S extends Selection<T>>(select: S & SelectionValidation<T, S>) => View<T, S>;
 //#endregion
-export { type ConnectionMetadata, type ConnectionRef, ConnectionTag, type Entity, type EntityId, FateClient, type FateLiveConnectionEvent, type FateLiveEvent, type FateMutations, type FateOperation, type FateProtocolRequest, type FateProtocolResponse, type AnyRecord as FateRecord, type FateRoots, type FateThenable, type InferFateAPI, type List, type ListEntry, type ListItem, type Mask, type MutationDefinition, type MutationEntity, type MutationIdentifier, type MutationInput, type MutationResult, type NodesItem, type Pagination, type Request$1 as Request, type RequestMode, type RequestOptions, type RequestResult, type Selection, type Snapshot, type Transport, type TypeConfig, type View, type ViewData, type ViewEntity, type ViewEntityName, type ViewRef, type ViewSelection, type ViewSnapshot, type ViewTag, clientRoot, createClient, createHTTPTransport, createTRPCTransport, getListEntries, getSelectionPlan, isRecord, isViewTag, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, mutation, toEntityId, view };
+export { type ConnectionMetadata, type ConnectionRef, ConnectionTag, type Entity, type EntityId, FateClient, type FateDehydratedState, type FateLiveConnectionEvent, type FateLiveEvent, type FateMutations, type FateOperation, type FateProtocolRequest, type FateProtocolResponse, type AnyRecord as FateRecord, type FateRoots, type FateThenable, type GraphQLMutationDefinition, type GraphQLMutationInput, type GraphQLMutationMap, type GraphQLMutationOutput, type GraphQLTransportOptions, type HydrateOptions, type HydrationLimits, type InferFateAPI, type List, type ListEntry, type ListItem, type Mask, type MutationDefinition, type MutationEntity, type MutationIdentifier, type MutationInput, type MutationResult, type NodesItem, type Pagination, type Request$1 as Request, type RequestMode, type RequestOptions, type RequestResult, type Selection, type Snapshot, type Transport, type TypeConfig, type View, type ViewData, type ViewEntity, type ViewEntityName, type ViewRef, type ViewSelection, type ViewSnapshot, type ViewTag, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, getListEntries, getSelectionPlan, graphqlMutation, isRecord, isViewTag, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, mutation, toEntityId, view };