@nkzw/fate 1.4.0 → 1.5.0

package/lib/hydration-DPZRJgnu.mjs

@@ -0,0 +1,273 @@
+//#region src/types.ts
+/** Internal marker added to objects that represent a view payload. */
+const ViewKind = Symbol("__fate__view");
+/** Symbol used to attach the set of view tags that were spread into a ref or masked record. */
+const ViewsTag = Symbol("__fate__views");
+/** Symbol used to brand a value as a node reference inside the cache. */
+const NodeRefTag = Symbol("__fate__node-ref");
+/** Symbol attached to connection results so pagination helpers can find their metadata. */
+const ConnectionTag = Symbol("__fate__connection");
+/** Symbol used to mark a selection as deferred. */
+const DeferTag = Symbol("__fate__defer");
+/** Symbol attached to deferred values returned from masked views. */
+const DeferredTag = Symbol("__fate__deferred");
+const viewTag = "__fate-view__";
+/** Generates a stable view tag for a view definition. */
+function getViewTag(id) {
+	return `${viewTag}${id}`;
+}
+/** Determines whether a property key is a fate view tag. */
+function isViewTag(key) {
+	return key.startsWith(viewTag);
+}
+/** Indicates whether a request item represents an explicit node ID. */
+function isNodeItem(item) {
+	return "id" in item;
+}
+/** Indicates whether a request item represents explicit node IDs. */
+function isNodesItem(item) {
+	return "ids" in item;
+}
+/** Indicates whether a request item represents a root query. */
+function isQueryItem(item) {
+	return "view" in item && !("id" in item) && !("ids" in item);
+}
+/** Brand used on root definitions to mark their identity in the d.ts output. */
+const RootKind = "__fate__root";
+/** Brand used on mutation definitions to mark their identity in the d.ts output. */
+const MutationKind = "__fate__mutation";
+//#endregion
+//#region src/node-ref.ts
+function createNodeRef(id) {
+	const ref = {};
+	Object.defineProperty(ref, NodeRefTag, {
+		configurable: false,
+		enumerable: false,
+		value: id,
+		writable: false
+	});
+	return Object.freeze(ref);
+}
+function isNodeRef(value) {
+	return !value || typeof value !== "object" ? false : NodeRefTag in value;
+}
+function getNodeRefId(ref) {
+	return ref[NodeRefTag];
+}
+//#endregion
+//#region src/hydration.ts
+const maxDepth = 64;
+const defaultHydrationLimits = {
+	maxCollectionLength: 1e5,
+	maxNodes: 25e4,
+	maxStringLength: 1e6
+};
+const resolveHydrationLimits = (limits) => {
+	const result = {
+		...defaultHydrationLimits,
+		...limits
+	};
+	for (const [key, value] of Object.entries(result)) if (!Number.isInteger(value) || value < 1) throw new Error(`fate: Hydration limit '${key}' must be a positive integer.`);
+	return result;
+};
+const error = (path, message) => /* @__PURE__ */ new Error(`fate: Cannot serialize hydration value at '${path}': ${message}`);
+const isPlainObject = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const isDenseArray = (value) => {
+	for (let index = 0; index < value.length; index += 1) if (!Object.hasOwn(value, index)) return false;
+	return true;
+};
+const isDate = (value) => Object.prototype.toString.call(value) === "[object Date]" && typeof value.getTime === "function" && typeof value.toISOString === "function";
+const encodeHydrationValue = (value, limits) => {
+	const resolvedLimits = resolveHydrationLimits(limits);
+	const seen = /* @__PURE__ */ new Set();
+	let nodes = 0;
+	const encode = (entry, path, depth) => {
+		nodes += 1;
+		if (nodes > resolvedLimits.maxNodes) throw error(path, `Maximum node count of ${String(resolvedLimits.maxNodes)} exceeded.`);
+		if (depth > maxDepth) throw error(path, `Maximum depth of ${String(maxDepth)} exceeded.`);
+		if (entry === null) return ["null"];
+		const type = typeof entry;
+		if (typeof entry === "string" || typeof entry === "boolean") {
+			if (typeof entry === "string" && entry.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
+			return [typeof entry, entry];
+		}
+		if (type === "number") {
+			if (Number.isNaN(entry)) return ["number", "NaN"];
+			if (entry === Infinity) return ["number", "Infinity"];
+			if (entry === -Infinity) return ["number", "-Infinity"];
+			if (Object.is(entry, -0)) return ["number", "-0"];
+			return ["number", entry];
+		}
+		if (type === "undefined") return ["undefined"];
+		if (type === "bigint") {
+			const bigint = String(entry);
+			if (bigint.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
+			return ["bigint", bigint];
+		}
+		if (type === "function" || type === "symbol") throw error(path, `Received unsupported '${type}' value.`);
+		if (!entry || typeof entry !== "object") throw error(path, `Received unsupported '${type}' value.`);
+		if (isNodeRef(entry)) {
+			const id = getNodeRefId(entry);
+			if (id.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
+			return ["ref", id];
+		}
+		if (isDate(entry)) {
+			if (Number.isNaN(entry.getTime())) throw error(path, `Received an invalid Date.`);
+			return ["date", entry.toISOString()];
+		}
+		if (seen.has(entry)) throw error(path, `Circular references are not supported.`);
+		seen.add(entry);
+		try {
+			if (Array.isArray(entry)) {
+				if (!isDenseArray(entry)) throw error(path, `Sparse arrays are not supported.`);
+				if (entry.length > resolvedLimits.maxCollectionLength) throw error(path, `Maximum collection length of ${String(resolvedLimits.maxCollectionLength)} exceeded.`);
+				return ["array", entry.map((item, index) => encode(item, `${path}[${String(index)}]`, depth + 1))];
+			}
+			if (!isPlainObject(entry)) throw error(path, `Received unsupported '${entry.constructor?.name ?? "object"}' value.`);
+			if (Object.getOwnPropertySymbols(entry).length > 0) throw error(path, `Received an unsupported symbol-keyed property.`);
+			const entries = Object.entries(entry);
+			if (entries.length > resolvedLimits.maxCollectionLength) throw error(path, `Maximum collection length of ${String(resolvedLimits.maxCollectionLength)} exceeded.`);
+			return ["object", entries.map(([key, item]) => {
+				if (key.length > resolvedLimits.maxStringLength) throw error(path, `Maximum string length of ${String(resolvedLimits.maxStringLength)} exceeded.`);
+				return [key, encode(item, `${path}.${key}`, depth + 1)];
+			})];
+		} finally {
+			seen.delete(entry);
+		}
+	};
+	return encode(value, "data", 0);
+};
+const invalidPayload = (path) => /* @__PURE__ */ new Error(`fate: Invalid hydration payload at '${path}'.`);
+const tagLengths = {
+	array: 2,
+	bigint: 2,
+	boolean: 2,
+	date: 2,
+	null: 1,
+	number: 2,
+	object: 2,
+	ref: 2,
+	string: 2,
+	undefined: 1
+};
+const decodeHydrationValue = (value, limits) => {
+	const resolvedLimits = resolveHydrationLimits(limits);
+	let nodes = 0;
+	const decode = (entry, path, depth) => {
+		nodes += 1;
+		if (nodes > resolvedLimits.maxNodes || depth > maxDepth || !Array.isArray(entry) || typeof entry[0] !== "string") throw invalidPayload(path);
+		const [tag, payload] = entry;
+		if (entry.length !== tagLengths[tag]) throw invalidPayload(path);
+		switch (tag) {
+			case "null": return null;
+			case "undefined": return;
+			case "string":
+				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
+				return payload;
+			case "boolean":
+				if (typeof payload !== "boolean") throw invalidPayload(path);
+				return payload;
+			case "number":
+				if (typeof payload === "number") {
+					if (!Number.isFinite(payload) || Object.is(payload, -0)) throw invalidPayload(path);
+					return payload;
+				}
+				if (payload === "NaN") return NaN;
+				if (payload === "Infinity") return Infinity;
+				if (payload === "-Infinity") return -Infinity;
+				if (payload === "-0") return -0;
+				throw invalidPayload(path);
+			case "bigint":
+				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
+				try {
+					const bigint = BigInt(payload);
+					if (String(bigint) !== payload) throw invalidPayload(path);
+					return bigint;
+				} catch {
+					throw invalidPayload(path);
+				}
+			case "date": {
+				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
+				const date = new Date(payload);
+				if (Number.isNaN(date.getTime()) || date.toISOString() !== payload) throw invalidPayload(path);
+				return date;
+			}
+			case "ref":
+				if (typeof payload !== "string" || payload.length > resolvedLimits.maxStringLength) throw invalidPayload(path);
+				return createNodeRef(payload);
+			case "array":
+				if (!Array.isArray(payload) || !isDenseArray(payload) || payload.length > resolvedLimits.maxCollectionLength) throw invalidPayload(path);
+				return payload.map((item, index) => decode(item, `${path}[${String(index)}]`, depth + 1));
+			case "object": {
+				if (!Array.isArray(payload) || payload.length > resolvedLimits.maxCollectionLength) throw invalidPayload(path);
+				const result = Object.create(null);
+				for (const item of payload) {
+					if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || item[0].length > resolvedLimits.maxStringLength) throw invalidPayload(path);
+					if (item[0] in result) throw invalidPayload(path);
+					result[item[0]] = decode(item[1], `${path}.${item[0]}`, depth + 1);
+				}
+				return result;
+			}
+			default: throw invalidPayload(path);
+		}
+	};
+	return decode(value, "data", 0);
+};
+const isRecord = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value) || isNodeRef(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const hasDuplicates = (values) => new Set(values).size !== values.length;
+const isUniqueStringArray = (value) => isStringArray(value) && !hasDuplicates(value);
+const hasOnlyKeys = (value, keys) => Object.keys(value).every((key) => keys.has(key));
+const listKeys = /* @__PURE__ */ new Set([
+	"backwardPageLimit",
+	"cursors",
+	"forwardPageLimit",
+	"ids",
+	"liveAfterIds",
+	"liveBeforeIds",
+	"pagination",
+	"pendingAfterIds",
+	"pendingBeforeIds"
+]);
+const paginationKeys = /* @__PURE__ */ new Set([
+	"hasNext",
+	"hasPrevious",
+	"nextCursor",
+	"previousCursor"
+]);
+const clientStateKeys = /* @__PURE__ */ new Set([
+	"rootLists",
+	"rootRequests",
+	"store"
+]);
+const storeStateKeys = /* @__PURE__ */ new Set([
+	"coverage",
+	"lists",
+	"records"
+]);
+const isEntry = (value) => Array.isArray(value) && value.length === 2 && typeof value[0] === "string";
+const isOptionalLimit = (value) => value === void 0 || typeof value === "number" && Number.isInteger(value) && value >= 0;
+const isPagination = (value) => value === void 0 || isRecord(value) && hasOnlyKeys(value, paginationKeys) && typeof value.hasNext === "boolean" && typeof value.hasPrevious === "boolean" && (value.nextCursor === void 0 || typeof value.nextCursor === "string") && (value.previousCursor === void 0 || typeof value.previousCursor === "string");
+const isList = (value) => {
+	if (!isRecord(value) || !hasOnlyKeys(value, listKeys) || !isStringArray(value.ids) || hasDuplicates(value.ids) || value.cursors !== void 0 && (!Array.isArray(value.cursors) || value.cursors.length !== value.ids.length)) return false;
+	return (value.cursors === void 0 || Array.isArray(value.cursors) && value.cursors.every((entry) => entry === void 0 || typeof entry === "string")) && (value.liveAfterIds === void 0 || isUniqueStringArray(value.liveAfterIds)) && (value.liveBeforeIds === void 0 || isUniqueStringArray(value.liveBeforeIds)) && isOptionalLimit(value.backwardPageLimit) && isOptionalLimit(value.forwardPageLimit) && isPagination(value.pagination) && (value.pendingAfterIds === void 0 || isUniqueStringArray(value.pendingAfterIds)) && (value.pendingBeforeIds === void 0 || isUniqueStringArray(value.pendingBeforeIds));
+};
+const isFieldPath = (value) => value.length > 0 && value.split(".").every((segment) => segment.length > 0);
+const isFieldPathArray = (value) => isUniqueStringArray(value) && value.every(isFieldPath);
+const hasDuplicateEntries = (entries) => hasDuplicates(entries.map((entry) => entry[0]));
+const decodeClientHydrationState = (value, limits) => {
+	const decoded = decodeHydrationValue(value, limits);
+	if (!isRecord(decoded) || !hasOnlyKeys(decoded, clientStateKeys) || !Array.isArray(decoded.rootLists) || !Array.isArray(decoded.rootRequests) || !isRecord(decoded.store) || !hasOnlyKeys(decoded.store, storeStateKeys) || !Array.isArray(decoded.store.coverage) || !Array.isArray(decoded.store.lists) || !Array.isArray(decoded.store.records)) throw invalidPayload("data");
+	if (decoded.rootLists.some((entry) => !isEntry(entry) || !isStringArray(entry[1])) || decoded.rootRequests.some((entry) => !isEntry(entry) || entry[1] !== null && typeof entry[1] !== "string") || decoded.store.coverage.some((entry) => !isEntry(entry) || !isFieldPathArray(entry[1])) || decoded.store.lists.some((entry) => !isEntry(entry) || !isList(entry[1])) || decoded.store.records.some((entry) => !isEntry(entry) || !isRecord(entry[1]))) throw invalidPayload("data");
+	if (hasDuplicateEntries(decoded.rootLists) || hasDuplicateEntries(decoded.rootRequests) || hasDuplicateEntries(decoded.store.coverage) || hasDuplicateEntries(decoded.store.lists) || hasDuplicateEntries(decoded.store.records) || decoded.rootLists.some(([, keys]) => hasDuplicates(keys))) throw invalidPayload("data");
+	return decoded;
+};
+//#endregion
+export { isNodesItem as _, createNodeRef as a, ConnectionTag as c, MutationKind as d, RootKind as f, isNodeItem as g, getViewTag as h, resolveHydrationLimits as i, DeferTag as l, ViewsTag as m, decodeHydrationValue as n, getNodeRefId as o, ViewKind as p, encodeHydrationValue as r, isNodeRef as s, decodeClientHydrationState as t, DeferredTag as u, isQueryItem as v, isViewTag as y };

package/lib/idempotency-types-CqA-BFpn.d.mts

@@ -0,0 +1,15 @@
+import { r as MutationIdentity } from "./transport-DqjhjLfC.mjs";
+//#region src/server/idempotency-types.d.ts
+/** Server enforcement for a durable mutation. The resolver must use the supplied context. */
+interface MutationIdempotency<Context> {
+  execute<Result>(options: {
+    ctx: Context;
+    identity: MutationIdentity;
+    input: unknown;
+    name: string;
+    resolve(ctx: Context): Promise<Result>;
+    select: Array<string>;
+  }): Promise<Result>;
+}
+//#endregion
+export { MutationIdempotency as t };

package/lib/idempotency.d.mts

@@ -0,0 +1,26 @@
+import { h as encodeHydrationValue } from "./transport-DqjhjLfC.mjs";
+import { t as MutationIdempotency } from "./idempotency-types-CqA-BFpn.mjs";
+//#region src/idempotency.d.ts
+type MutationReceipt = Readonly<{
+  fingerprint: string;
+  result: ReturnType<typeof encodeHydrationValue>;
+}>;
+/**
+ * All methods and the resolver run in ONE application database transaction.
+ * The adapter must serialize concurrent calls for the same scope and ID,
+ * including calls from different processes. Receipts must not expire.
+ */
+interface IdempotencyStore<Context> {
+  transaction<T>(context: Context, scope: string, id: string, run: (transaction: {
+    context: Context;
+    read(): Promise<MutationReceipt | undefined>;
+    write(receipt: MutationReceipt): Promise<void>;
+  }) => Promise<T>): Promise<T>;
+}
+/** Enforces durable deduplication using the application's own transaction adapter. */
+declare function createMutationIdempotency<Context>(options: {
+  scope(context: Context): string | Promise<string>;
+  store: IdempotencyStore<Context>;
+}): MutationIdempotency<Context>;
+//#endregion
+export { IdempotencyStore, type MutationIdempotency, MutationReceipt, createMutationIdempotency };

package/lib/idempotency.mjs

@@ -0,0 +1,34 @@
+import { n as decodeHydrationValue, r as encodeHydrationValue } from "./hydration-DPZRJgnu.mjs";
+import { t as FateRequestError } from "./protocol-DS5sf6sd.mjs";
+import { t as sortObjectKeys } from "./sortObjectKeys-yhuitEQZ.mjs";
+//#region src/idempotency.ts
+/** Enforces durable deduplication using the application's own transaction adapter. */
+function createMutationIdempotency(options) {
+	return { async execute({ ctx, identity, input, name, resolve, select }) {
+		const scope = await options.scope(ctx);
+		if (!scope || scope !== identity.scope) throw new FateRequestError("FORBIDDEN", "Mutation identity does not match the authenticated persistence scope.");
+		if (!identity.id || identity.id.length > 256 || identity.replayOnly !== void 0 && identity.replayOnly !== true) throw new FateRequestError("BAD_REQUEST", "Invalid mutation identity.");
+		const fingerprint = JSON.stringify(encodeHydrationValue(sortObjectKeys({
+			input,
+			name,
+			select: [...select].sort()
+		})));
+		return options.store.transaction(ctx, scope, identity.id, async (transaction) => {
+			const receipt = await transaction.read();
+			if (receipt) {
+				if (receipt.fingerprint !== fingerprint) throw new FateRequestError("BAD_REQUEST", "Mutation identity was reused with different input.");
+				return decodeHydrationValue(receipt.result);
+			}
+			if (identity.replayOnly) throw new FateRequestError("NOT_FOUND", "Mutation receipt was not found.");
+			const result = await resolve(transaction.context);
+			const encoded = encodeHydrationValue(result);
+			await transaction.write({
+				fingerprint,
+				result: encoded
+			});
+			return result;
+		});
+	} };
+}
+//#endregion
+export { createMutationIdempotency };

package/lib/index.d.mts

@@ -1,7 +1,7 @@
-import { $ as HydrationLimits, A as TypeConfig, B as __FateEntityBrand, C as MutationShape, D as RequestResult, E as Request$1, F as ViewEntityName, G as DeferredSnapshot, H as isViewTag, I as ViewRef, J as RequestOptions, K as FateClient, L as ViewSelection, M as View, N as ViewData, O as RootDefinition, P as ViewEntity, Q as HydrateOptions, R as ViewSnapshot, S as MutationResult, T as Pagination, U as FateMutations, V as __FateSelectionBrand, W as mutation, X as getSelectionPlan, Y as createClient, Z as FateDehydratedState, _ as Mask, a as ConnectionRef, b as MutationIdentifier, c as Deferred, d as DeferredTag, et as List, f as Entity, g as ListItem, h as FateThenable, i as ConnectionMetadata, j as TypeName, k as Selection, l as DeferredMetadata, m as FateRoots, n as createTRPCTransport, o as ConnectionTag, p as EntityId, q as RequestMode, r as AnyRecord, s as DeferTag, t as Transport, u as DeferredSelection, v as MutationDefinition, w as NodesItem, x as MutationInput, y as MutationEntity, z as ViewTag } from "./transport-Bo1Jgo9R.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-BDR1pnUQ.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-BTUXkHQU.mjs";
-import { n as getListEntries, t as ListEntry } from "./list-Bb1SeABn.mjs";
+import { $ as ViewSnapshot, A as FateThenable, B as Pagination, C as Deferred, D as Entity, E as DeferredTag, F as MutationIdentifier, G as TypeConfig, H as RequestResult, I as MutationInput, J as ViewData, K as TypeName, L as MutationResult, M as Mask, N as MutationDefinition, O as EntityId, P as MutationEntity, Q as ViewSelection, R as MutationShape, S as DeferTag, T as DeferredSelection, U as RootDefinition, V as Request$1, W as Selection, X as ViewEntityName, Y as ViewEntity, Z as ViewRef, _ as getSelectionPlan, a as PersistenceSession, at as mutation, b as ConnectionRef, c as FateClient, d as createClient, et as ViewTag, f as FateDehydratedState, g as List, i as Persistence, it as FateMutations, j as ListItem, k as FateRoots, l as RequestMode, m as HydrationLimits, n as createTRPCTransport, nt as __FateSelectionBrand, o as PersistenceSnapshot, p as HydrateOptions, q as View, r as MutationIdentity, rt as isViewTag, s as DeferredSnapshot, t as Transport, tt as __FateEntityBrand, u as RequestOptions, v as AnyRecord, w as DeferredMetadata, x as ConnectionTag, y as ConnectionMetadata, z as NodesItem } from "./transport-DqjhjLfC.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-DGLYyRxL.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-DITM4zb_.mjs";
+import { n as getListEntries, t as ListEntry } from "./list-BRT1VtiT.mjs";
 //#region src/defer.d.ts
 declare function defer<S>(selection: S): DeferredSelection<S>;
 declare const isDeferred: (value: unknown) => value is Deferred<unknown>;
@@ -84,4 +84,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, DeferTag, type Deferred, type DeferredMetadata, type DeferredSelection, type DeferredSnapshot, DeferredTag, 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 Transport, type TypeConfig, type View, type ViewData, type ViewEntity, type ViewEntityName, type ViewRef, type ViewSelection, type ViewSnapshot, type ViewTag, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, defer, getDeferredMetadata, getListEntries, getSelectionPlan, graphqlMutation, isDeferred, isRecord, isViewTag, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, mutation, toEntityId, view };
+export { type ConnectionMetadata, type ConnectionRef, ConnectionTag, DeferTag, type Deferred, type DeferredMetadata, type DeferredSelection, type DeferredSnapshot, DeferredTag, 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 MutationIdentity, type MutationInput, type MutationResult, type NodesItem, type Pagination, type Persistence, type PersistenceSession, type PersistenceSnapshot, type Request$1 as Request, type RequestMode, type RequestOptions, type RequestResult, type Selection, 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, defer, getDeferredMetadata, getListEntries, getSelectionPlan, graphqlMutation, isDeferred, isRecord, isViewTag, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, mutation, toEntityId, view };