@nkzw/fate 1.0.3 → 1.2.0

package/lib/{types-Dz46PXr3.d.mts → transport-BjGm__3t.d.mts}

@@ -1,32 +1,6 @@
 import { TRPCClient } from "@trpc/client";
 
-//#region src/mask.d.ts
-type FieldMask = {
-  all: boolean;
-  children: Map<string, FieldMask>;
-};
-//#endregion
-//#region src/selection.d.ts
-/**
- * Representation of a composed selection including hashed args and the
- * flat set of field paths to read or fetch.
- */
-type SelectionPlan = {
-  readonly args: Map<string, Readonly<{
-    hash: string;
-    ignoreKeys?: ReadonlySet<string>;
-    value: AnyRecord;
-  }>>;
-  readonly live: Map<string, ConnectionLivePolicy>;
-  readonly paths: Set<string>;
-};
-/**
- * Flattens a view into a `SelectionPlan`, expanding composed views and
- * partitioning nested args so the client can fetch exactly what is declared.
- */
-declare const getSelectionPlan: <T extends Entity, S extends Selection<T>, V extends View<T, S>>(viewComposition: V, ref: ViewRef<T["__typename"]> | null) => SelectionPlan;
-//#endregion
-//#region ../../node_modules/.pnpm/@trpc+server@11.17.0_typescript@5.9.3/node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
+//#region ../../node_modules/.pnpm/@trpc+server@11.17.0_typescript@6.0.3/node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
 //#region src/observable/types.d.ts
 interface Unsubscribable {
   unsubscribe(): void;
@@ -50,7 +24,7 @@ interface Observer<TValue, TError> {
 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.17.0_typescript@5.9.3/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-BdVSvUCr.d.mts
+//#region ../../node_modules/.pnpm/@trpc+server@11.17.0_typescript@6.0.3/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-BdVSvUCr.d.mts
 /**
  * @public
  */
@@ -613,123 +587,18 @@ interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
 }
 type AnyRouter = Router<any, any>;
 //#endregion
-//#region src/transport.d.ts
-/**
- * Normalized representation of args passed to a transport.
- */
-type ResolvedArgsPayload = AnyRecord;
-type TransportMutations = Record<string, MutationShape>;
-type EmptyTransportMutations = Record<never, MutationShape>;
-type Bivariant<Fn extends (...args: Array<any>) => any> = {
-  bivarianceHack: Fn;
-}['bivarianceHack'];
-type TRPCListResult = {
-  items: Array<{
-    cursor?: string;
-    node?: unknown;
-  }>;
-  pagination: Pagination;
+//#region src/mask.d.ts
+type FieldMask = {
+  all: boolean;
+  children: Map<string, FieldMask>;
 };
-type LiveEventHandlers = Readonly<{
-  onData: (record: unknown, select?: ReadonlyArray<string>) => void;
-  onDelete?: (id?: string | number) => void;
-  onError?: (error: unknown) => void;
-}>;
-type LiveConnectionEvent = Readonly<{
-  edge: {
-    cursor?: string;
-    node: unknown;
-  };
-  nodeType: string;
-  targetCursor?: string;
-  type: 'appendEdge' | 'appendNode' | 'insertEdgeAfter' | 'insertEdgeBefore' | 'prependEdge' | 'prependNode';
-}> | Readonly<{
-  id: string | number;
-  nodeType: string;
-  type: 'deleteEdge';
-}> | Readonly<{
-  type: 'invalidate';
-}>;
-type LiveConnectionEventHandlers = Readonly<{
-  onError?: (error: unknown) => void;
-  onEvent: (event: LiveConnectionEvent) => void;
-}>;
-/**
- * Contract the fate client expects from a network transport. The transport is
- * responsible for fetching records by ID, fetching lists, and executing
- * mutations with the provided selections.
- */
-interface Transport<Mutations extends TransportMutations = EmptyTransportMutations> {
-  fetchById(type: string, ids: Array<string | number>, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<Array<unknown>>;
-  fetchList?(proc: string, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<{
-    items: Array<{
-      cursor: string | undefined;
-      node: unknown;
-    }>;
-    pagination: Pagination;
-  }>;
-  fetchQuery?(proc: string, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<unknown>;
-  mutate?<K extends Extract<keyof Mutations, string>>(proc: K, input: Mutations[K]['input'], select: Set<string>): Promise<Mutations[K]['output']>;
-  subscribeById?(type: string, id: string | number, select: Iterable<string>, args: ResolvedArgsPayload | undefined, handlers: LiveEventHandlers): () => void;
-  subscribeConnection?(procedure: string, type: string, args: ResolvedArgsPayload | undefined, select: Iterable<string>, selectionArgs: ResolvedArgsPayload | undefined, handlers: LiveConnectionEventHandlers): () => void;
-}
-/**
- * Mapping of entity type to tRPC procedures used for fetching entities by ID.
- */
-type TRPCByIdResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => (input: {
-  args?: ResolvedArgsPayload;
-  ids: Array<string | number>;
-  select: Array<string>;
-}) => Promise<unknown>>;
-/**
- * Mapping of list procedure name to a tRPC resolver factory.
- */
-type TRPCListResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => Bivariant<(input: any) => Promise<TRPCListResult>>>;
-/**
- * Mapping of query procedure name to a tRPC resolver factory.
- */
-type TRPCQueryResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => (input: {
-  args?: ResolvedArgsPayload;
-  select: Array<string>;
-}) => Promise<unknown>>;
-/**
- * Mapping of a mutation procedure name to a tRPC resolver factory.
- */
-type MutationResolver<AppRouter extends AnyRouter> = (client: TRPCClient<AppRouter>) => (input: any) => Promise<any>;
-type TRPCMutationResolvers<AppRouter extends AnyRouter> = Record<string, MutationResolver<AppRouter>>;
-type MutationMapFromResolvers<R extends Record<string, MutationResolver<any>>> = { [K in keyof R]: R[K] extends ((client: any) => (input: infer Input) => Promise<infer Output>) ? {
-  input: Input;
-  output: Output;
-} : never };
-type EmptyMutationResolvers<AppRouter extends AnyRouter> = Record<never, MutationResolver<AppRouter>>;
-/**
- * Builds a `Transport` backed by a tRPC client using the configured resolvers
- * for by-id queries, lists, and mutations.
- */
-declare function createTRPCTransport<AppRouter extends AnyRouter, Mutations extends TRPCMutationResolvers<AppRouter> = EmptyMutationResolvers<AppRouter>>({
-  byId,
-  client,
-  lists,
-  mutations,
-  queries
-}: {
-  byId: TRPCByIdResolvers<AppRouter>;
-  client: TRPCClient<AppRouter>;
-  lists?: TRPCListResolvers<AppRouter>;
-  mutations?: Mutations;
-  queries?: TRPCQueryResolvers<AppRouter>;
-}): Transport<MutationMapFromResolvers<Mutations>>;
-//#endregion
-//#region src/operation-lifetime.d.ts
-type RetainHandle = Readonly<{
-  dispose(): void;
-}>;
 //#endregion
 //#region src/cache.d.ts
 declare class ViewDataCache {
   private cache;
   private rootDependencies;
   private dependencyIndex;
+  clear(): void;
   get<T extends Entity, S extends Selection<T>, V extends View<T, S>>(entityId: EntityId, view: V, ref: ViewRef<T['__typename']>): FateThenable<ViewSnapshot<T, S>> | null;
   set<T extends Entity, S extends Selection<T>, V extends View<T, S>>(entityId: EntityId, view: V, ref: ViewRef<T['__typename']>, thenable: FateThenable<ViewSnapshot<T, S>>, dependencies: ReadonlySet<EntityId>): void;
   invalidate(entityId: EntityId): void;
@@ -749,6 +618,11 @@ type List = Readonly<{
   pendingAfterIds?: ReadonlyArray<EntityId>;
   pendingBeforeIds?: ReadonlyArray<EntityId>;
 }>;
+type StoreHydrationState = Readonly<{
+  coverage: ReadonlyArray<readonly [EntityId, ReadonlyArray<string>]>;
+  lists: ReadonlyArray<readonly [string, List]>;
+  records: ReadonlyArray<readonly [EntityId, AnyRecord]>;
+}>;
 declare class Store {
   private coverage;
   private listKeysByOwnerField;
@@ -759,6 +633,11 @@ declare class Store {
   private records;
   private subscriptions;
   private listSubscriptions;
+  dehydrate(): StoreHydrationState;
+  hydrate(state: StoreHydrationState, mode: 'preserve-existing' | 'replace', options?: {
+    deferNotifications?: boolean;
+  }): () => void;
+  private rebuildIndexes;
   read(id: EntityId): AnyRecord | undefined;
   merge(id: EntityId, partial: AnyRecord, paths: Iterable<string>): void;
   private mergeInternal;
@@ -796,6 +675,61 @@ declare class Store {
   private updateRecordReferenceIndexes;
 }
 //#endregion
+//#region src/hydration.d.ts
+/** JSON-safe opaque value contained in a dehydrated fate snapshot. */
+type FateSerializedValue = null | boolean | number | string | ReadonlyArray<FateSerializedValue> | Readonly<{
+  [key: string]: FateSerializedValue;
+}>;
+/** Versioned, JSON-safe durable cache snapshot produced by `FateClient.dehydrate()`. */
+declare const hydrationScopeBrand: unique symbol;
+type FateDehydratedState<Scope extends string = string> = Readonly<{
+  data: FateSerializedValue;
+  readonly [hydrationScopeBrand]?: Scope;
+  scope: Scope;
+  version: 1;
+}>;
+/** Controls how `FateClient.hydrate()` reconciles a snapshot with browser cache state. */
+type HydrateOptions = Readonly<{
+  /**
+   * `preserve-existing` keeps browser values and list windows when conflicts
+   * occur. `replace` treats the snapshot as authoritative.
+   *
+   * @defaultValue 'preserve-existing'
+   */
+  merge?: 'preserve-existing' | 'replace';
+}>;
+/** Resource limits applied while encoding and decoding hydration snapshots. */
+type HydrationLimits = Readonly<{
+  /** Maximum number of entries in any encoded array or object. */maxCollectionLength: number; /** Maximum number of encoded values in a hydration snapshot. */
+  maxNodes: number; /** Maximum length of an encoded string, object key, or bigint payload. */
+  maxStringLength: number;
+}>;
+//#endregion
+//#region src/selection.d.ts
+/**
+ * Representation of a composed selection including hashed args and the
+ * flat set of field paths to read or fetch.
+ */
+type SelectionPlan = {
+  readonly args: Map<string, Readonly<{
+    hash: string;
+    ignoreKeys?: ReadonlySet<string>;
+    value: AnyRecord;
+  }>>;
+  readonly live: Map<string, ConnectionLivePolicy>;
+  readonly paths: Set<string>;
+};
+/**
+ * Flattens a view into a `SelectionPlan`, expanding composed views and
+ * partitioning nested args so the client can fetch exactly what is declared.
+ */
+declare const getSelectionPlan: <T extends Entity, S extends Selection<T>, V extends View<T, S>>(viewComposition: V, ref: ViewRef<T["__typename"]> | null) => SelectionPlan;
+//#endregion
+//#region src/operation-lifetime.d.ts
+type RetainHandle = Readonly<{
+  dispose(): void;
+}>;
+//#endregion
 //#region src/client.d.ts
 /**
  * Strategy used when resolving a request.
@@ -807,7 +741,11 @@ type RequestMode = /** (default) Use cached data if present, otherwise fetch. */
 type RequestOptions = Readonly<{
   mode?: RequestMode;
 }>;
-type FateClientOptions<Roots extends FateRoots, Mutations extends FateMutations> = {
+type DeferredSnapshot<T> = Readonly<{
+  coverage: ReadonlyArray<readonly [id: EntityId, paths: ReadonlySet<string>]>;
+  data: T;
+}>;
+type FateClientOptions<Roots extends FateRoots, Mutations extends FateMutations, HydrationScope extends string> = {
   /**
    * Number of recently released requests to keep retained before their records
    * and lists are eligible for garbage collection.
@@ -815,6 +753,15 @@ type FateClientOptions<Roots extends FateRoots, Mutations extends FateMutations>
    * @defaultValue 10
    */
   gcReleaseBufferSize?: number;
+  /**
+   * Bounds hydration snapshot encoding and decoding work.
+   */
+  hydrationLimits?: Partial<HydrationLimits>;
+  /**
+   * Identifies snapshots compatible with this client. Change this value when
+   * deploying an incompatible cache schema or separating cache namespaces.
+   */
+  hydrationScope?: HydrationScope;
   mutations?: Mutations;
   onLiveError?: (error: unknown) => void;
   roots: Roots;
@@ -827,11 +774,12 @@ type FateClientOptions<Roots extends FateRoots, Mutations extends FateMutations>
  * Core client that normalizes records, manages the view cache, and coordinates
  * data fetching.
  */
-declare class FateClient<Roots extends FateRoots, Mutations extends FateMutations> {
+declare class FateClient<Roots extends FateRoots, Mutations extends FateMutations, HydrationScope extends string = string> {
   private readonly mutationMap;
   private readonly parentLists;
   private readonly rootLists;
   private readonly pending;
+  private readonly pendingDeferred;
   private readonly pendingOptimisticMutations;
   private readonly optimisticMasks;
   private readonly optimisticByEntity;
@@ -846,8 +794,11 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   private readonly stalledRequests;
   private gcPending;
   private gcScheduled;
+  private pendingNetworkRequests;
   readonly store: Store;
   private readonly operationLifetime;
+  private readonly hydrationLimits;
+  private readonly hydrationScope;
   private readonly types;
   private readonly transport;
   private readonly viewDataCache;
@@ -855,8 +806,20 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   readonly actions: MutationActionsFor<Mutations>;
   readonly mutations: MutationFunctionsFor<Mutations>;
   readonly roots: Roots;
-  constructor(options: FateClientOptions<Roots, Mutations>);
+  constructor(options: FateClientOptions<Roots, Mutations, HydrationScope>);
   private initializeParentLists;
+  /**
+   * Exports the durable normalized cache as an opaque JSON-safe value for SSR
+   * transfer or persistence. Runtime requests, subscriptions, retainers, and
+   * optimistic state are intentionally excluded.
+   */
+  dehydrate(): FateDehydratedState<HydrationScope>;
+  /**
+   * Restores a durable normalized cache snapshot without restoring runtime
+   * request handles, retainers, subscriptions, or optimistic update state.
+   * Hydrate before rendering SSR content. Replaying the same snapshot is safe.
+   */
+  hydrate(state: FateDehydratedState<HydrationScope>, options?: HydrateOptions): void;
   private registerRootList;
   private snapshotList;
   private applyListInsert;
@@ -878,6 +841,7 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
     [ViewsTag]: Set<string>;
   }>;
   readView<T extends Entity, S extends Selection<T>, V extends View<T, S>>(view: V, ref: ViewRef<T['__typename']>): FateThenable<ViewSnapshot<T, S>>;
+  readDeferred<T>(deferred: Deferred<T>): PromiseLike<DeferredSnapshot<T>>;
   assertLiveViewSupport(): void;
   assertLiveConnectionSupport(): void;
   subscribeLiveView<T extends Entity, S extends Selection<T>, V extends View<T, S>>(view: V, ref: ViewRef<T['__typename']>): () => void;
@@ -914,6 +878,7 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
     pendingAfterIds?: ReadonlyArray<EntityId>;
     pendingBeforeIds?: ReadonlyArray<EntityId>;
   }> | undefined>;
+  private loadConnectionInternal;
   request<R extends Request$1>(request: R, options?: RequestOptions): Promise<RequestResult<Roots, R>>;
   requestForRender<R extends Request$1>(request: R, options?: RequestOptions): Promise<RequestResult<Roots, R>>;
   prepareRequestForRender<R extends Request$1>(request: R, options: RequestOptions | undefined): Readonly<{
@@ -946,6 +911,8 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   private executeRequestHandle;
   private markRecordReferences;
   private hasActiveOptimisticUpdates;
+  private hasPendingRequests;
+  trackPendingRequest<T>(request: () => Promise<T>): Promise<T>;
   private runPendingGarbageCollection;
   private handleStoreAndNetworkRequest;
   private getRootType;
@@ -965,12 +932,15 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   private clearStalledRequestsForEntity;
   private pendingPrefix;
   private pendingKey;
+  private deferredPendingKey;
+  private deferredSelectionSignature;
+  private hasMissingDeferredList;
   private liveSubscriptionKey;
   private liveConnectionSubscriptionKey;
   private releaseLiveSubscription;
   private reportLiveError;
 }
-declare function createClient<T extends [FateRoots, FateMutations] = [Record<never, RootDefinition<any, any>>, Record<never, MutationDefinition<any, any, any>>]>(options: FateClientOptions<T[0], T[1]>): FateClient<T[0], T[1]>;
+declare function createClient<T extends [FateRoots, FateMutations] = [Record<never, RootDefinition<any, any>>, Record<never, MutationDefinition<any, any, any>>], HydrationScope extends string = string>(options: FateClientOptions<T[0], T[1], HydrationScope>): FateClient<T[0], T[1], HydrationScope>;
 //#endregion
 //#region src/mutation.d.ts
 /**
@@ -1043,6 +1013,10 @@ declare const ViewKind: unique symbol;
 declare const ViewsTag: unique symbol;
 /** Symbol attached to connection results so pagination helpers can find their metadata. */
 declare const ConnectionTag: unique symbol;
+/** Symbol used to mark a selection as deferred. */
+declare const DeferTag: unique symbol;
+/** Symbol attached to deferred values returned from masked views. */
+declare const DeferredTag: unique symbol;
 declare const __FateEntityBrand: unique symbol;
 declare const __FateSelectionBrand: unique symbol;
 declare const __FateMutationEntityBrand: unique symbol;
@@ -1050,6 +1024,7 @@ declare const __FateMutationInputBrand: unique symbol;
 declare const __FateMutationResultBrand: unique symbol;
 declare const __FateRootResultBrand: unique symbol;
 declare const __FateRootTypeBrand: unique symbol;
+declare const __FateDeferredBrand: unique symbol;
 type __ViewEntityAnchor<T extends Entity> = {
   readonly [__FateEntityBrand]?: T;
 };
@@ -1136,6 +1111,24 @@ type ConnectionRef<TName extends string> = Readonly<{
   }>;
   pagination?: Pagination;
 }>;
+/** Selection wrapper created by `defer(...)`. */
+type DeferredSelection<S> = Readonly<{
+  [DeferTag]: S;
+}>;
+/** Runtime metadata used by the client to resolve a deferred field. */
+type DeferredMetadata = Readonly<{
+  field: string;
+  id: string | number;
+  owner: EntityId;
+  selection: unknown;
+  type: string;
+}>;
+/** A deferred value returned from a masked view. Existing view hooks resolve it when read. */
+type Deferred<T> = Readonly<{
+  [DeferredTag]: DeferredMetadata;
+}> & {
+  readonly [__FateDeferredBrand]: T;
+};
 /** Base shape shared by all entities fetched by fate. */
 type Entity = {
   __typename: string;
@@ -1159,7 +1152,8 @@ type ConnectionSelectionBase<T extends Entity> = Readonly<{
 type ConnectionSelection<T extends Entity> = ConnectionSelectionBase<T> | (SelectionArgs & ConnectionSelectionBase<T>);
 type BaseSelectionFieldValue<T extends Entity, K extends keyof T> = NonNullable<T[K]> extends Array<infer U extends Entity> ? true | Selection<U> | ConnectionSelection<U> | View<U, Selection<U>> : NonNullable<T[K]> extends Entity ? true | Selection<NonNullable<T[K]>> | View<NonNullable<T[K]>, Selection<NonNullable<T[K]>>> : NonNullable<T[K]> extends AnyRecord ? PlainObjectSelection<NonNullable<T[K]>> : true;
 type SelectionFieldValue<T extends Entity, K extends keyof T> = BaseSelectionFieldValue<T, K> | SelectionArgs | (SelectionArgs & Extract<BaseSelectionFieldValue<T, K>, object>);
-type SelectionShape<T extends Entity> = { [K in keyof T as K extends '__typename' ? never : K]?: SelectionFieldValue<T, K> } & {
+type DeferrableSelectionFieldValue<T extends Entity, K extends keyof T> = SelectionFieldValue<T, K> | DeferredSelection<SelectionFieldValue<T, K>>;
+type SelectionShape<T extends Entity> = { [K in keyof T as K extends '__typename' ? never : K]?: DeferrableSelectionFieldValue<T, K> } & {
   __typename?: true;
 };
 type SelectionViewSpread<T extends Entity> = { readonly [K in ViewTag]?: Readonly<{
@@ -1221,7 +1215,7 @@ type EntityName<T> = T extends {
   __typename: infer N extends string;
 } ? N : never;
 /** Recursively applies a view selection to an entity to mask fields that aren't selected. */
-type MaskNonNullish<T, S> = T extends Array<infer U extends Entity> ? S extends true ? Array<U> : S extends ConnectionLikeSelection ? ConnectionMask<U, S> : HasViewTag<S> extends true ? Array<ViewRef<U['__typename']>> : Array<Mask<U, S>> : S extends true ? T : S extends object ? HasViewTag<S> extends true ? NonNullish<T> extends Entity ? ViewRef<EntityName<NonNullish<T>>> : ViewRef<EntityName<NonNullable<T>>> : { [K in keyof S as K extends 'args' ? never : K]: S[K] extends true ? NonNullish<T>[Extract<K, keyof T>] : Mask<NonNullish<T>[Extract<K, keyof T>], Extract<S[K], object>> } & (T extends Entity ? Pick<NonNullish<T>, '__typename'> : Record<never, never>) : T;
+type MaskNonNullish<T, S> = T extends Array<infer U extends Entity> ? S extends true ? Array<U> : S extends ConnectionLikeSelection ? ConnectionMask<U, S> : HasViewTag<S> extends true ? Array<ViewRef<U['__typename']>> : Array<Mask<U, S>> : S extends true ? T : S extends object ? HasViewTag<S> extends true ? NonNullish<T> extends Entity ? ViewRef<EntityName<NonNullish<T>>> : ViewRef<EntityName<NonNullable<T>>> : { [K in keyof S as K extends 'args' ? never : K]: S[K] extends true ? NonNullish<T>[Extract<K, keyof T>] : S[K] extends DeferredSelection<infer DeferredSelectionValue> ? Deferred<Mask<NonNullish<T>[Extract<K, keyof T>], DeferredSelectionValue>> : Mask<NonNullish<T>[Extract<K, keyof T>], Extract<S[K], object>> } & (T extends Entity ? Pick<NonNullish<T>, '__typename'> : Record<never, never>) : T;
 type Mask<T, S> = WithNullish<T, MaskNonNullish<NonNullish<T>, S>>;
 /** Entity type captured from a view definition. */
 type ViewEntity<V> = V extends View<infer T, any> ? T : never;
@@ -1342,4 +1336,111 @@ interface FateThenable<T> extends PromiseLike<T> {
   value: T;
 }
 //#endregion
-export { ViewRef as A, RequestMode as B, Snapshot as C, ViewData as D, View as E, __FateSelectionBrand as F, createTRPCTransport as G, createClient as H, isViewTag as I, getSelectionPlan as J, AnyProcedure as K, FateMutations as L, ViewSnapshot as M, ViewTag as N, ViewEntity as O, __FateEntityBrand as P, mutation as R, Selection as S, TypeName as T, List as U, RequestOptions as V, Transport as W, NodesItem as _, Entity as a, RequestResult as b, FateThenable as c, MutationDefinition as d, MutationEntity as f, MutationShape as g, MutationResult as h, ConnectionTag as i, ViewSelection as j, ViewEntityName as k, ListItem as l, MutationInput as m, ConnectionMetadata as n, EntityId as o, MutationIdentifier as p, QueryProcedure as q, ConnectionRef as r, FateRoots as s, AnyRecord as t, Mask as u, Pagination as v, TypeConfig as w, RootDefinition as x, Request$1 as y, FateClient as z };
+//#region src/transport.d.ts
+/**
+ * Normalized representation of args passed to a transport.
+ */
+type ResolvedArgsPayload = AnyRecord;
+type TransportMutations = Record<string, MutationShape>;
+type EmptyTransportMutations = Record<never, MutationShape>;
+type Bivariant<Fn extends (...args: Array<any>) => any> = {
+  bivarianceHack: Fn;
+}['bivarianceHack'];
+type TRPCListResult = {
+  items: Array<{
+    cursor?: string;
+    node?: unknown;
+  }>;
+  pagination: Pagination;
+};
+type LiveEventHandlers = Readonly<{
+  onData: (record: unknown, select?: ReadonlyArray<string>) => void;
+  onDelete?: (id?: string | number) => void;
+  onError?: (error: unknown) => void;
+}>;
+type LiveConnectionEvent = Readonly<{
+  edge: {
+    cursor?: string;
+    node: unknown;
+  };
+  nodeType: string;
+  targetCursor?: string;
+  type: 'appendEdge' | 'appendNode' | 'insertEdgeAfter' | 'insertEdgeBefore' | 'prependEdge' | 'prependNode';
+}> | Readonly<{
+  id: string | number;
+  nodeType: string;
+  type: 'deleteEdge';
+}> | Readonly<{
+  type: 'invalidate';
+}>;
+type LiveConnectionEventHandlers = Readonly<{
+  onError?: (error: unknown) => void;
+  onEvent: (event: LiveConnectionEvent) => void;
+}>;
+/**
+ * Contract the fate client expects from a network transport. The transport is
+ * responsible for fetching records by ID, fetching lists, and executing
+ * mutations with the provided selections.
+ */
+interface Transport<Mutations extends TransportMutations = EmptyTransportMutations> {
+  fetchById(type: string, ids: Array<string | number>, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<Array<unknown>>;
+  fetchList?(proc: string, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<{
+    items: Array<{
+      cursor: string | undefined;
+      node: unknown;
+    }>;
+    pagination: Pagination;
+  }>;
+  fetchQuery?(proc: string, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<unknown>;
+  mutate?<K extends Extract<keyof Mutations, string>>(proc: K, input: Mutations[K]['input'], select: Set<string>): Promise<Mutations[K]['output']>;
+  subscribeById?(type: string, id: string | number, select: Iterable<string>, args: ResolvedArgsPayload | undefined, handlers: LiveEventHandlers): () => void;
+  subscribeConnection?(procedure: string, type: string, args: ResolvedArgsPayload | undefined, select: Iterable<string>, selectionArgs: ResolvedArgsPayload | undefined, handlers: LiveConnectionEventHandlers): () => void;
+}
+/**
+ * Mapping of entity type to tRPC procedures used for fetching entities by ID.
+ */
+type TRPCByIdResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => (input: {
+  args?: ResolvedArgsPayload;
+  ids: Array<string | number>;
+  select: Array<string>;
+}) => Promise<unknown>>;
+/**
+ * Mapping of list procedure name to a tRPC resolver factory.
+ */
+type TRPCListResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => Bivariant<(input: any) => Promise<TRPCListResult>>>;
+/**
+ * Mapping of query procedure name to a tRPC resolver factory.
+ */
+type TRPCQueryResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => (input: {
+  args?: ResolvedArgsPayload;
+  select: Array<string>;
+}) => Promise<unknown>>;
+/**
+ * Mapping of a mutation procedure name to a tRPC resolver factory.
+ */
+type MutationResolver<AppRouter extends AnyRouter> = (client: TRPCClient<AppRouter>) => (input: any) => Promise<any>;
+type TRPCMutationResolvers<AppRouter extends AnyRouter> = Record<string, MutationResolver<AppRouter>>;
+type MutationMapFromResolvers<R extends Record<string, MutationResolver<any>>> = { [K in keyof R]: R[K] extends ((client: any) => (input: infer Input) => Promise<infer Output>) ? {
+  input: Input;
+  output: Output;
+} : never };
+type EmptyMutationResolvers<AppRouter extends AnyRouter> = Record<never, MutationResolver<AppRouter>>;
+/**
+ * Builds a `Transport` backed by a tRPC client using the configured resolvers
+ * for by-id queries, lists, and mutations.
+ */
+declare function createTRPCTransport<AppRouter extends AnyRouter, Mutations extends TRPCMutationResolvers<AppRouter> = EmptyMutationResolvers<AppRouter>>({
+  byId,
+  client,
+  lists,
+  mutations,
+  queries
+}: {
+  byId: TRPCByIdResolvers<AppRouter>;
+  client: TRPCClient<AppRouter>;
+  lists?: TRPCListResolvers<AppRouter>;
+  mutations?: Mutations;
+  queries?: TRPCQueryResolvers<AppRouter>;
+}): Transport<MutationMapFromResolvers<Mutations>>;
+//#endregion
+export { HydrateOptions as $, Snapshot as A, ViewTag as B, MutationShape as C, RequestResult as D, Request$1 as E, ViewEntity as F, mutation as G, __FateSelectionBrand as H, ViewEntityName as I, RequestMode as J, DeferredSnapshot as K, ViewRef as L, TypeName as M, View as N, RootDefinition as O, ViewData as P, FateDehydratedState as Q, ViewSelection as R, MutationResult as S, Pagination as T, isViewTag as U, __FateEntityBrand as V, FateMutations as W, createClient as X, RequestOptions as Y, getSelectionPlan as Z, Mask as _, ConnectionRef as a, MutationIdentifier as b, Deferred as c, DeferredTag as d, HydrationLimits as et, Entity as f, ListItem as g, FateThenable as h, ConnectionMetadata as i, TypeConfig as j, Selection as k, DeferredMetadata as l, FateRoots as m, createTRPCTransport as n, AnyProcedure as nt, ConnectionTag as o, EntityId as p, FateClient as q, AnyRecord as r, QueryProcedure as rt, DeferTag as s, Transport as t, List as tt, DeferredSelection as u, MutationDefinition as v, NodesItem as w, MutationInput as x, MutationEntity as y, ViewSnapshot as z };

package/lib/vite.d.mts

@@ -1,10 +1,10 @@
 import { Plugin } from "vite";
 
 //#region src/viteTypes.d.ts
-type FateViteTransport = 'native' | 'trpc' | 'void';
+type FateViteTransport = 'graphql' | 'native' | 'trpc' | 'void';
 //#endregion
 //#region src/vite.d.ts
-type ClientRuntime = '@nkzw/fate' | 'react-fate';
+type ClientRuntime = '@nkzw/fate' | 'react-fate' | 'vue-fate';
 type FateVitePluginOptions = {
   clientModule?: ClientRuntime;
   generatedFile?: false | string;