@nkzw/fate 0.1.2 → 1.0.0-rc.0

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

@@ -17,83 +17,40 @@ type SelectionPlan = {
     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$1 extends Entity, S extends Selection<T$1>, V extends View<T$1, S>>(viewComposition: V, ref: ViewRef<T$1["__typename"]> | null) => SelectionPlan;
+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/cache.d.ts
-declare class ViewDataCache {
-  private cache;
-  private rootDependencies;
-  private dependencyIndex;
-  get<T$1 extends Entity, S extends Selection<T$1>, V extends View<T$1, S>>(entityId: EntityId, view: V, ref: ViewRef<T$1['__typename']>): FateThenable<ViewSnapshot<T$1, S>> | null;
-  set<T$1 extends Entity, S extends Selection<T$1>, V extends View<T$1, S>>(entityId: EntityId, view: V, ref: ViewRef<T$1['__typename']>, thenable: FateThenable<ViewSnapshot<T$1, S>>, dependencies: ReadonlySet<EntityId>): void;
-  invalidate(entityId: EntityId): void;
-  private invalidateDependents;
-  private delete;
-}
-//#endregion
-//#region src/store.d.ts
-type List = Readonly<{
-  cursors?: ReadonlyArray<string | undefined>;
-  ids: ReadonlyArray<EntityId>;
-  pagination?: Pagination;
-}>;
-declare class Store {
-  private coverage;
-  private lists;
-  private records;
-  private subscriptions;
-  private listSubscriptions;
-  read(id: EntityId): AnyRecord | undefined;
-  merge(id: EntityId, partial: AnyRecord, paths: Iterable<string>): void;
-  private mergeInternal;
-  deleteRecord(id: EntityId): void;
-  missingForSelection(id: EntityId, paths: Iterable<string>): Set<string>;
-  subscribe(id: EntityId, selection: ReadonlySet<string> | null, fn: () => void): () => void;
-  subscribe(id: EntityId, fn: () => void): () => void;
-  private notify;
-  private notifyListSubscribers;
-  getList(key: string): ReadonlyArray<EntityId> | undefined;
-  getListState(key: string): List | undefined;
-  getListsForField(ownerId: EntityId, field: string): Array<readonly [string, List]>;
-  setList(key: string, state: List): void;
-  restoreList(key: string, list?: List): void;
-  subscribeList(key: string, fn: () => void): () => void;
-  removeReferencesTo(targetId: EntityId, viewDataCache: ViewDataCache, snapshots?: Map<EntityId, Snapshot>, listSnapshots?: Map<string, List>): void;
-  snapshot(id: EntityId): Snapshot;
-  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 ../../node_modules/.pnpm/@trpc+server@11.17.0_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 Subscribable<TValue, TError> {
+  subscribe(observer: Partial<Observer<TValue, 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 Observable<TValue, TError> extends Subscribable<TValue, TError> {
+  pipe(): Observable<TValue, TError>;
+  pipe<TValue1, TError1>(op1: OperatorFunction<TValue, TError, TValue1, TError1>): Observable<TValue1, TError1>;
+  pipe<TValue1, TError1, TValue2, TError2>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(op1: OperatorFunction<TValue, 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, 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, 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;
+interface Observer<TValue, TError> {
+  next: (value: TValue) => 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
+//#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
 /**
  * @public
  */
@@ -148,7 +105,6 @@ 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";
@@ -157,8 +113,7 @@ declare class TRPCError extends Error {
     code: TRPC_ERROR_CODE_KEY;
     cause?: unknown;
   });
-}
-//# sourceMappingURL=TRPCError.d.ts.map
+} //# sourceMappingURL=TRPCError.d.ts.map
 //#endregion
 //#region src/vendor/standard-schema-v1/spec.d.ts
 /**
@@ -166,28 +121,28 @@ declare class TRPCError extends Error {
  * @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> {
+interface StandardSchemaV1<Input = unknown, Output = Input> {
   /** The Standard Schema properties. */
-  readonly '~standard': StandardSchemaV1.Props<Input$1, Output$1>;
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
 }
 declare namespace StandardSchemaV1 {
   /** The Standard Schema properties interface. */
-  interface Props<Input$1 = unknown, Output$1 = Input$1> {
+  interface Props<Input = unknown, Output = Input> {
     /** 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>>;
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
     /** Inferred types associated with the schema. */
-    readonly types?: Types<Input$1, Output$1> | undefined;
+    readonly types?: Types<Input, Output> | undefined;
   }
   /** The result interface of the validate function. */
-  type Result<Output$1> = SuccessResult<Output$1> | FailureResult;
+  type Result<Output> = SuccessResult<Output> | FailureResult;
   /** The result interface if validation succeeds. */
-  interface SuccessResult<Output$1> {
+  interface SuccessResult<Output> {
     /** The typed output value. */
-    readonly value: Output$1;
+    readonly value: Output;
     /** The non-existent issues. */
     readonly issues?: undefined;
   }
@@ -209,18 +164,17 @@ declare namespace StandardSchemaV1 {
     readonly key: PropertyKey;
   }
   /** The Standard Schema types interface. */
-  interface Types<Input$1 = unknown, Output$1 = Input$1> {
+  interface Types<Input = unknown, Output = Input> {
     /** The input type of the schema. */
-    readonly input: Input$1;
+    readonly input: Input;
     /** The output type of the schema. */
-    readonly output: Output$1;
+    readonly output: Output;
   }
   /** 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
+} //# sourceMappingURL=spec.d.ts.map
 //#endregion
 //#region src/unstable-core-do-not-import/parser.d.ts
 type ParserZodEsque<TInput, TParsedInput> = {
@@ -259,15 +213,18 @@ type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
 /**
  * @internal
  */
-interface ProcedureCallOptions<TContext$1> {
-  ctx: TContext$1;
+interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
   getRawInput: GetRawInputFn;
   input?: unknown;
   path: string;
   type: ProcedureType;
   signal: AbortSignal | undefined;
-}
-//#endregion
+  /**
+   * The index of this call in a batch request.
+   */
+  batchIndex: number;
+} //#endregion
 //#region src/unstable-core-do-not-import/procedure.d.ts
 declare const procedureTypes: readonly ["query", "mutation", "subscription"];
 /**
@@ -331,19 +288,17 @@ type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>['$types
 /**
  * @internal
  */
-interface ErrorHandlerOptions<TContext$1> {
+interface ErrorHandlerOptions<TContext> {
   error: TRPCError;
   type: ProcedureType | 'unknown';
   path: string | undefined;
   input: unknown;
-  ctx: TContext$1 | undefined;
-}
-//#endregion
+  ctx: TContext | 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
 /**
@@ -357,7 +312,6 @@ interface TRPCErrorShape<TData extends object = object> {
 /**
  * JSON-RPC 2.0 Specification
  */
-
 //# sourceMappingURL=envelopes.d.ts.map
 //#endregion
 //#region src/unstable-core-do-not-import/transformer.d.ts
@@ -404,20 +358,18 @@ interface CombinedDataTransformer {
 /**
  * @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: {
+type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: {
   error: TRPCError;
   type: ProcedureType | 'unknown';
   path: string | undefined;
   input: unknown;
-  ctx: TContext$1 | undefined;
+  ctx: TContext | undefined;
   shape: DefaultErrorShape;
 }) => TShape;
 /**
@@ -468,7 +420,6 @@ interface JSONLProducerOptions {
  * 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
@@ -495,9 +446,9 @@ interface SSEClientOptions {
    */
   reconnectAfterInactivityMs?: number;
 }
-interface SSEStreamProducerOptions<TValue$1 = unknown> {
+interface SSEStreamProducerOptions<TValue = unknown> {
   serialize?: Serialize$1;
-  data: AsyncIterable<TValue$1>;
+  data: AsyncIterable<TValue>;
   maxDepth?: number;
   ping?: SSEPingOptions;
   /**
@@ -524,7 +475,6 @@ interface SSEStreamProducerOptions<TValue$1 = unknown> {
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-
 //#endregion
 //#region src/unstable-core-do-not-import/rootConfig.d.ts
 /**
@@ -540,7 +490,6 @@ interface RootTypes {
 /**
  * The default check to see if we're in a server
  */
-
 /**
  * The tRPC root config
  * @internal
@@ -621,7 +570,7 @@ type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TReco
 /**
  * @internal
  */
-type RouterCallerErrorHandler<TContext$1> = (opts: ErrorHandlerOptions<TContext$1>) => void;
+type RouterCallerErrorHandler<TContext> = (opts: ErrorHandlerOptions<TContext>) => void;
 /**
  * @internal
  */
@@ -644,7 +593,6 @@ type LazyLoader<TAny> = {
  * Lazy load a router
  * @see https://trpc.io/docs/server/merging-routers#lazy-load
  */
-
 /**
  * @internal
  */
@@ -675,6 +623,37 @@ 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
@@ -690,7 +669,9 @@ interface Transport<Mutations extends TransportMutations = EmptyTransportMutatio
     pagination: Pagination;
   }>;
   fetchQuery?(proc: string, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<unknown>;
-  mutate?<K$1 extends Extract<keyof Mutations, string>>(proc: K$1, input: Mutations[K$1]['input'], select: Set<string>): Promise<Mutations[K$1]['output']>;
+  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.
@@ -699,17 +680,11 @@ type TRPCByIdResolvers<AppRouter extends AnyRouter> = Record<string, (client: TR
   args?: ResolvedArgsPayload;
   ids: Array<string | number>;
   select: Array<string>;
-}) => Promise<Array<unknown>>>;
+}) => 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<{
-  items: Array<{
-    cursor: string | undefined;
-    node: unknown;
-  }>;
-  pagination: Pagination;
-}>>>;
+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.
  */
@@ -722,7 +697,7 @@ type TRPCQueryResolvers<AppRouter extends AnyRouter> = Record<string, (client: T
  */
 type MutationResolver<AppRouter extends AnyRouter> = (client: TRPCClient<AppRouter>) => (input: any) => Promise<any>;
 type TRPCMutationResolvers<AppRouter extends AnyRouter> = Record<string, MutationResolver<AppRouter>>;
-type MutationMapFromResolvers<R$1 extends Record<string, MutationResolver<any>>> = { [K in keyof R$1]: R$1[K] extends ((client: any) => (input: infer Input) => Promise<infer Output>) ? {
+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 };
@@ -745,14 +720,87 @@ declare function createTRPCTransport<AppRouter extends AnyRouter, Mutations exte
   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;
+  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;
+  private invalidateDependents;
+  private delete;
+}
+//#endregion
+//#region src/store.d.ts
+type List = Readonly<{
+  backwardPageLimit?: number;
+  cursors?: ReadonlyArray<string | undefined>;
+  forwardPageLimit?: number;
+  ids: ReadonlyArray<EntityId>;
+  liveAfterIds?: ReadonlyArray<EntityId>;
+  liveBeforeIds?: ReadonlyArray<EntityId>;
+  pagination?: Pagination;
+  pendingAfterIds?: ReadonlyArray<EntityId>;
+  pendingBeforeIds?: ReadonlyArray<EntityId>;
+}>;
+declare class Store {
+  private coverage;
+  private listKeysByOwnerField;
+  private listKeysByReferencedEntity;
+  private lists;
+  private recordReferenceFields;
+  private recordReferencesByTarget;
+  private records;
+  private subscriptions;
+  private listSubscriptions;
+  read(id: EntityId): AnyRecord | undefined;
+  merge(id: EntityId, partial: AnyRecord, paths: Iterable<string>): void;
+  private mergeInternal;
+  deleteRecord(id: EntityId): void;
+  missingForSelection(id: EntityId, paths: Iterable<string>): Set<string>;
+  subscribe(id: EntityId, selection: ReadonlySet<string> | null, fn: () => void): () => void;
+  subscribe(id: EntityId, fn: () => void): () => void;
+  private notify;
+  private notifyListSubscribers;
+  getList(key: string): ReadonlyArray<EntityId> | undefined;
+  getListState(key: string): List | undefined;
+  getListsForField(ownerId: EntityId, field: string): Array<readonly [string, List]>;
+  setList(key: string, state: List): void;
+  replaceListEntityId(previousId: EntityId, nextId: EntityId): void;
+  restoreList(key: string, list?: List): void;
+  collectGarbage(markedRecords: ReadonlySet<EntityId>, markedLists: ReadonlySet<string>, options?: {
+    onRecordDeleted?: (id: EntityId) => void;
+  }): {
+    lists: Set<string>;
+    records: Set<EntityId>;
+  };
+  private deleteList;
+  subscribeList(key: string, fn: () => void): () => void;
+  removeReferencesTo(targetId: EntityId, viewDataCache: ViewDataCache, snapshots?: Map<EntityId, Snapshot>, listSnapshots?: Map<string, List>): void;
+  snapshot(id: EntityId): Snapshot;
+  restore(id: EntityId, snapshot: Snapshot): void;
+  private addListIndexes;
+  private removeListIndexes;
+  private getListReferencedEntityIds;
+  private getRecordFieldReferences;
+  private addRecordFieldReferenceIndex;
+  private removeRecordFieldReferenceIndex;
+  private addRecordReferenceIndexes;
+  private removeRecordReferenceIndexes;
+  private updateRecordReferenceIndexes;
+}
+//#endregion
 //#region src/client.d.ts
 /**
  * Strategy used when resolving a request.
  */
-type RequestMode = /** (default) Use cached data if present, otherwise fetch. */
-'cache-first'
-/** Show cached data immediately and refresh in the background. */ | 'stale-while-revalidate'
-/** Always fetch from the network and ignore cached entries. */ | 'network-only';
+type RequestMode = /** (default) Use cached data if present, otherwise fetch. */'cache-first' /** Show cached data immediately and refresh in the background. */ | 'stale-while-revalidate' /** Always fetch from the network and ignore cached entries. */ | 'network-only';
 /**
  * Request options that affect how requests are fetched and retained.
  */
@@ -760,7 +808,15 @@ type RequestOptions = Readonly<{
   mode?: RequestMode;
 }>;
 type FateClientOptions<Roots extends FateRoots, Mutations extends FateMutations> = {
+  /**
+   * Number of recently released requests to keep retained before their records
+   * and lists are eligible for garbage collection.
+   *
+   * @defaultValue 10
+   */
+  gcReleaseBufferSize?: number;
   mutations?: Mutations;
+  onLiveError?: (error: unknown) => void;
   roots: Roots;
   transport: Transport<MutationMapFromDefinitions<Mutations>>;
   types: ReadonlyArray<Omit<TypeConfig, 'getId'> & Partial<{
@@ -781,36 +837,58 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   private readonly optimisticByEntity;
   private readonly optimisticEntityResolutions;
   private optimisticTokenCounter;
+  private readonly onLiveError;
+  private readonly liveSubscriptions;
+  private readonly liveConnectionInvalidations;
+  private readonly stableRefs;
   private readonly requests;
   private readonly rootRequests;
   private readonly stalledRequests;
+  private gcPending;
+  private gcScheduled;
   readonly store: Store;
+  private readonly operationLifetime;
   private readonly types;
   private readonly transport;
   private readonly viewDataCache;
+  private liveConnectionInvalidationToken;
   readonly actions: MutationActionsFor<Mutations>;
   readonly mutations: MutationFunctionsFor<Mutations>;
   readonly roots: Roots;
   constructor(options: FateClientOptions<Roots, Mutations>);
   private initializeParentLists;
   private registerRootList;
+  private snapshotList;
+  private applyListInsert;
   private insertIntoRootLists;
   getTypeConfig(type: string): TypeConfig;
   executeMutation(key: string, input: unknown, select: Set<string>, options?: {
     args?: AnyRecord;
     plan?: SelectionPlan;
   }): Promise<unknown>;
-  write(type: string, data: AnyRecord, select: ReadonlySet<string>, snapshots?: Map<EntityId, Snapshot>, plan?: SelectionPlan, pathPrefix?: string | null, blockedMask?: FieldMask | null, insert?: InsertPosition): string;
+  write(type: string, data: AnyRecord, select: ReadonlySet<string>, snapshots?: Map<EntityId, Snapshot>, plan?: SelectionPlan, pathPrefix?: string | null, blockedMask?: FieldMask | null, insert?: InsertPosition, listSnapshots?: Map<string, List>): string;
   deleteRecord(type: string, id: string | number, snapshots?: Map<EntityId, Snapshot>, listSnapshots?: Map<string, List>): void;
   restore(id: EntityId, snapshot: Snapshot): void;
   restoreList(name: string, list?: List): void;
-  ref<T$1 extends Entity>(type: T$1['__typename'], id: string | number, view: View<T$1, Selection<T$1>>): ViewRef<T$1['__typename']>;
+  private stableRefWithViewNames;
+  ref<T extends Entity>(type: T['__typename'], id: string | number, view: View<T, Selection<T>>): ViewRef<T['__typename']>;
   rootListRef(entityId: EntityId, rootView: View<any, any>): Readonly<{
     __typename: string;
     id: string | number;
     [ViewsTag]: Set<string>;
   }>;
-  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>>;
+  readView<T extends Entity, S extends Selection<T>, V extends View<T, S>>(view: V, ref: ViewRef<T['__typename']>): FateThenable<ViewSnapshot<T, S>>;
+  assertLiveViewSupport(): void;
+  assertLiveConnectionSupport(): void;
+  subscribeLiveView<T extends Entity, S extends Selection<T>, V extends View<T, S>>(view: V, ref: ViewRef<T['__typename']>): () => void;
+  subscribeLiveListView<V extends View<any, any>>(view: V, connection: ConnectionMetadata): () => void;
+  private applyLiveConnectionEvent;
+  private invalidateLiveConnection;
+  private deleteConnectionEdge;
+  private insertConnectionEdge;
+  private syncNestedConnectionOwnerField;
+  private getConnectionInsertIndex;
+  private removeEntityFromListState;
   private mergeListState;
   registerPendingOptimisticMutation(entityId: EntityId, promise: Promise<unknown>): void;
   resolveOptimisticEntity(optimisticEntityId: EntityId, resolvedEntityId: EntityId): void;
@@ -826,36 +904,80 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   loadConnection<V extends View<any, any>>(view: V, connection: ConnectionMetadata, args: Record<string, unknown>, options?: {
     direction?: 'forward' | 'backward';
   }): Promise<Readonly<{
+    backwardPageLimit?: number;
     cursors?: ReadonlyArray<string | undefined>;
+    forwardPageLimit?: number;
     ids: ReadonlyArray<EntityId>;
+    liveAfterIds?: ReadonlyArray<EntityId>;
+    liveBeforeIds?: ReadonlyArray<EntityId>;
     pagination?: Pagination;
+    pendingAfterIds?: ReadonlyArray<EntityId>;
+    pendingBeforeIds?: ReadonlyArray<EntityId>;
   }> | undefined>;
-  request<R$1 extends Request$1>(request: R$1, options?: RequestOptions): Promise<RequestResult<Roots, R$1>>;
+  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<{
+    promise: Promise<RequestResult<Roots, R>>;
+    requestKey: string;
+  }>;
+  private requestWithDescriptor;
   releaseRequest(request: Request$1, mode: RequestMode): void;
+  releaseRequestKey(requestKey: string, mode: RequestMode): void;
+  retainRequestKey(requestKey: string, mode?: RequestMode): RetainHandle;
+  /**
+   * Keeps the records and lists reachable from a request alive until the
+   * returned handle is disposed.
+   *
+   * `useRequest` calls this automatically while the component is mounted.
+   * Use it directly for non-React request lifetimes, tests, or preloaded data
+   * that must survive manual garbage collection.
+   */
+  retain(request: Request$1): RetainHandle;
+  private scheduleGarbageCollection;
+  /**
+   * Removes records and lists that are not reachable from retained requests or
+   * the release buffer.
+   *
+   * Garbage collection is scheduled automatically when retained requests are
+   * released. Calling this method manually is mainly useful in tests and custom
+   * memory-management flows.
+   */
+  gc(): void;
+  private executeRequestHandle;
+  private markRecordReferences;
+  private hasActiveOptimisticUpdates;
+  private runPendingGarbageCollection;
   private handleStoreAndNetworkRequest;
   private getRootType;
+  private createRequestDescriptor;
+  getRequestKey(request: Request$1): string;
+  private hasRootListData;
   private executeRequest;
   private hasRequestData;
-  getRequestResult<R$1 extends Request$1>(request: R$1): RequestResult<Roots, R$1>;
+  getRequestResult<R extends Request$1>(request: R): RequestResult<Roots, R>;
+  private getRequestResultFromDescriptor;
   private fetchByIdAndNormalize;
   private fetchQueryAndNormalize;
   private fetchListAndNormalize;
-  private resolveSelection;
   private writeEntity;
   private linkParentLists;
   private readViewSelection;
   private clearStalledRequestsForEntity;
   private pendingPrefix;
   private pendingKey;
+  private liveSubscriptionKey;
+  private liveConnectionSubscriptionKey;
+  private releaseLiveSubscription;
+  private reportLiveError;
 }
-declare function createClient<T$1 extends [FateRoots, FateMutations] = [Record<never, RootDefinition<any, any>>, Record<never, MutationDefinition<any, any, any>>]>(options: FateClientOptions<T$1[0], T$1[1]>): FateClient<T$1[0], T$1[1]>;
+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]>;
 //#endregion
 //#region src/mutation.d.ts
 /**
  * Defines a mutation for a given entity type, preserving the input and output
  * types for transports.
  */
-declare function mutation<T$1 extends Entity, I$1, R$1>(entity: T$1['__typename']): MutationDefinition<T$1, I$1, R$1>;
+declare function mutation<T extends Entity, I, R>(entity: T['__typename']): MutationDefinition<T, I, R>;
 /** Where (or if) to insert the resulting record into relevant lists. */
 type InsertPosition = 'after' | 'before' | 'none';
 /**
@@ -863,25 +985,20 @@ type InsertPosition = 'after' | 'before' | 'none';
  * optional selection for the returned payload.
  */
 type MutationOptions<Identifier extends MutationIdentifier<any, any, any>> = {
-  /** Optional arguments to pass to the mutation resolver. */
-  args?: Record<string, unknown>;
-  /** If true, deletes the record with the ID specified in the input. */
-  delete?: boolean;
-  /** Input data for the mutation. */
+  /** Optional arguments to pass to the mutation resolver. */args?: Record<string, unknown>; /** If true, deletes the record with the ID specified in the input. */
+  delete?: boolean; /** Input data for the mutation. */
   input: Omit<MutationInput<Identifier>, 'select'>;
-  insert?: InsertPosition;
-  /** Optional optimistic update to apply immediately. */
-  optimistic?: OptimisticUpdate<MutationResult<Identifier>>;
-  /** Optional view specifying which fields to select from the server. */
+  insert?: InsertPosition; /** Optional optimistic update to apply immediately. */
+  optimistic?: OptimisticUpdate<MutationResult<Identifier>>; /** Optional view specifying which fields to select from the server. */
   view?: View<MutationEntity<Identifier>, Selection<MutationEntity<Identifier>>>;
 };
 /**
  * Callable mutation entry point returned on the client that resolves to either
  * a successful result or an error.
  */
-type MutationFunction<I$1 extends MutationIdentifier<any, any, any>> = (options: MutationOptions<I$1>) => Promise<{
+type MutationFunction<I extends MutationIdentifier<any, any, any>> = (options: MutationOptions<I>) => Promise<{
   error: undefined;
-  result: MutationResult<I$1>;
+  result: MutationResult<I>;
 } | {
   error: Error;
   result: undefined;
@@ -890,21 +1007,22 @@ type MutationFunction<I$1 extends MutationIdentifier<any, any, any>> = (options:
  * React action-compatible wrapper that can be passed directly to form actions
  * or transitions.
  */
-type MutationAction<I$1 extends MutationIdentifier<any, any, any>> = (previousState: unknown,
+type MutationAction<I extends MutationIdentifier<any, any, any>> = (previousState: unknown,
 /**
  * Mutation options or 'reset' to reset the action state.
  */
-options: MutationOptions<I$1> | 'reset') => Promise<{
+
+options: MutationOptions<I> | 'reset') => Promise<{
   error: undefined;
-  result: MutationResult<I$1>;
+  result: MutationResult<I>;
 } | {
   error: Error;
   result: undefined;
 }>;
-type MutationIdentifierFor<K$1 extends string, Def extends MutationDefinition<any, any, any>> = Def extends MutationDefinition<infer T, infer I, infer R> ? MutationIdentifier<T, I, R> & Readonly<{
-  key: K$1;
+type MutationIdentifierFor<K extends string, Def extends MutationDefinition<any, any, any>> = Def extends MutationDefinition<infer T, infer I, infer R> ? MutationIdentifier<T, I, R> & Readonly<{
+  key: K;
 }> : never;
-type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 type NestedValue<Path extends string, Value> = Path extends `${infer Head}.${infer Tail}` ? { [K in Head]: NestedValue<Tail, Value> } : { [K in Path]: Value };
 /**
  * Base type for client mutations.
@@ -932,26 +1050,26 @@ declare const __FateMutationInputBrand: unique symbol;
 declare const __FateMutationResultBrand: unique symbol;
 declare const __FateRootResultBrand: unique symbol;
 declare const __FateRootTypeBrand: unique symbol;
-type __ViewEntityAnchor<T$1 extends Entity> = {
-  readonly [__FateEntityBrand]?: T$1;
+type __ViewEntityAnchor<T extends Entity> = {
+  readonly [__FateEntityBrand]?: T;
 };
 type __ViewSelectionAnchor<S> = {
   [__FateSelectionBrand]?: S;
 };
-type __MutationEntityAnchor<T$1 extends Entity> = {
-  readonly [__FateMutationEntityBrand]?: T$1;
+type __MutationEntityAnchor<T extends Entity> = {
+  readonly [__FateMutationEntityBrand]?: T;
 };
-type __MutationInputAnchor<I$1> = {
-  readonly [__FateMutationInputBrand]?: I$1;
+type __MutationInputAnchor<I> = {
+  readonly [__FateMutationInputBrand]?: I;
 };
-type __MutationResultAnchor<R$1> = {
-  readonly [__FateMutationResultBrand]?: R$1;
+type __MutationResultAnchor<R> = {
+  readonly [__FateMutationResultBrand]?: R;
 };
-type __RootResultAnchor<R$1> = {
-  readonly [__FateRootResultBrand]?: R$1;
+type __RootResultAnchor<R> = {
+  readonly [__FateRootResultBrand]?: R;
 };
-type __RootTypeAnchor<T$1 extends TypeName> = {
-  readonly [__FateRootTypeBrand]?: T$1;
+type __RootTypeAnchor<T extends TypeName> = {
+  readonly [__FateRootTypeBrand]?: T;
 };
 /** Unique key that identifies a view composition entry inside a selection or reference. */
 type ViewTag = `__fate-view__${string}`;
@@ -959,18 +1077,27 @@ type ViewTag = `__fate-view__${string}`;
 declare function isViewTag(key: string): key is ViewTag;
 /** Alias for a loose record used throughout the fate's internals. */
 type AnyRecord = Record<string, unknown>;
-type Nullish<T$1> = Extract<T$1, null | undefined>;
-type NonNullish<T$1> = Exclude<T$1, null | undefined>;
-type WithNullish<T$1, R$1> = R$1 | Nullish<T$1>;
+type Nullish<T> = Extract<T, null | undefined>;
+type NonNullish<T> = Exclude<T, null | undefined>;
+type WithNullish<T, R> = R | Nullish<T>;
 type SelectionArgs = Readonly<{
   args: AnyRecord;
 }>;
+type ConnectionLivePolicy = Readonly<{
+  append?: 'edge' | 'visible';
+  prepend?: 'edge' | 'visible';
+}>;
+type ConnectionLiveSelectionPolicy = Readonly<{
+  append?: ConnectionLivePolicy['append'] | string;
+  prepend?: ConnectionLivePolicy['prepend'] | string;
+}>;
 /** Metadata stored alongside connection results to power pagination and cache updates. */
 type ConnectionMetadata = Readonly<{
   args?: AnyRecord;
   field: string;
   hash?: string;
   key: string;
+  live?: ConnectionLivePolicy;
   owner: EntityId;
   procedure: string;
   root?: boolean;
@@ -983,12 +1110,9 @@ type ViewRef<TName extends string> = Readonly<{
   [ViewsTag]: Set<string>;
 }>;
 /** Describes how a field relates to another entity for normalization. */
-type RelationDescriptor = /** Field stores a scalar value that does not link to another type. */
-'scalar'
-/** Field points to a single entity of the given type. */ | {
+type RelationDescriptor = /** Field stores a scalar value that does not link to another type. */'scalar' /** Field points to a single entity of the given type. */ | {
   type: string;
-}
-/** Field holds a list of entities of the given type. */ | {
+} /** Field holds a list of entities of the given type. */ | {
   listOf: string;
 };
 /** Configuration for a server entity type used by the client cache. */
@@ -1017,12 +1141,13 @@ type Entity = {
   __typename: string;
 };
 type PlainObjectSelectionField<V> = V extends Array<infer U> ? PlainObjectSelectionField<U> | true : V extends AnyRecord ? PlainObjectSelection<V> | true : true;
-type PlainObjectSelection<T$1> = { [K in keyof T$1]?: PlainObjectSelectionField<T$1[K]> };
-type ConnectionSelectionBase<T$1 extends Entity> = Readonly<{
+type PlainObjectSelection<T> = { [K in keyof T]?: PlainObjectSelectionField<T[K]> };
+type ConnectionSelectionBase<T extends Entity> = Readonly<{
   items: Readonly<{
     cursor?: true;
-    node: Selection<T$1> | View<T$1, Selection<T$1>>;
+    node: Selection<T> | View<T, Selection<T>>;
   }>;
+  live?: ConnectionLiveSelectionPolicy;
   pagination?: Readonly<{
     hasNext?: true;
     hasPrevious?: true;
@@ -1031,27 +1156,27 @@ type ConnectionSelectionBase<T$1 extends Entity> = Readonly<{
   }>;
 }>;
 /** Selection shape for a connection-style list, including pagination metadata and optional arguments. */
-type ConnectionSelection<T$1 extends Entity> = ConnectionSelectionBase<T$1> | (SelectionArgs & ConnectionSelectionBase<T$1>);
-type BaseSelectionFieldValue<T$1 extends Entity, K$1 extends keyof T$1> = NonNullable<T$1[K$1]> extends Array<infer U extends Entity> ? true | Selection<U> | ConnectionSelection<U> | View<U, Selection<U>> : NonNullable<T$1[K$1]> extends Entity ? true | Selection<NonNullable<T$1[K$1]>> | View<NonNullable<T$1[K$1]>, Selection<NonNullable<T$1[K$1]>>> : NonNullable<T$1[K$1]> extends AnyRecord ? PlainObjectSelection<NonNullable<T$1[K$1]>> : true;
-type SelectionFieldValue<T$1 extends Entity, K$1 extends keyof T$1> = BaseSelectionFieldValue<T$1, K$1> | SelectionArgs | (SelectionArgs & Extract<BaseSelectionFieldValue<T$1, K$1>, object>);
-type SelectionShape<T$1 extends Entity> = { [K in keyof T$1 as K extends '__typename' ? never : K]?: SelectionFieldValue<T$1, K> } & {
+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> } & {
   __typename?: true;
 };
-type SelectionViewSpread<T$1 extends Entity> = { readonly [K in ViewTag]?: Readonly<{
-  select: Selection<T$1>;
+type SelectionViewSpread<T extends Entity> = { readonly [K in ViewTag]?: Readonly<{
+  select: Selection<T>;
   [ViewKind]: true;
 }> };
 /** Declarative selection of the fields a view needs from an entity. */
-type Selection<T$1 extends Entity> = SelectionShape<T$1> & SelectionViewSpread<T$1>;
+type Selection<T extends Entity> = SelectionShape<T> & SelectionViewSpread<T>;
 /** View payload stored on a view tag containing the raw selection used to mask data. */
-type ViewPayload<T$1 extends Entity, S extends Selection<T$1> = Selection<T$1>> = Readonly<{
+type ViewPayload<T extends Entity, S extends Selection<T> = Selection<T>> = Readonly<{
   select: S;
   [ViewKind]: true;
 }>;
 /** Definition of a view over an entity type, including the selection of fields. */
-type View<T$1 extends Entity, S extends Selection<T$1> = Selection<T$1>> = Readonly<{
-  [viewTag: ViewTag]: ViewPayload<T$1, S>;
-}> & __ViewEntityAnchor<T$1> & __ViewSelectionAnchor<S>;
+type View<T extends Entity, S extends Selection<T> = Selection<T>> = Readonly<{
+  [viewTag: ViewTag]: ViewPayload<T, S>;
+}> & __ViewEntityAnchor<T> & __ViewSelectionAnchor<S>;
 type HasViewTag<S> = S extends { [K in ViewTag]?: infer P } ? P extends {
   [ViewKind]: true;
 } ? true : false : false;
@@ -1059,40 +1184,45 @@ type HasViewTag<S> = S extends { [K in ViewTag]?: infer P } ? P extends {
  * Data returned from a resolved view with masking applied and view tags
  * attached for downstream composition.
  */
-type ViewData<T$1 extends Entity, S extends Selection<T$1>> = Readonly<(S extends Selection<T$1> ? Mask<T$1, S> : T$1) & {
+type ViewData<T extends Entity, S extends Selection<T>> = Readonly<(S extends Selection<T> ? Mask<T, S> : T) & {
   [ViewsTag]: Set<string>;
 }>;
 /**
  * Snapshot returned by the cache for a view, including the masked data and all
  * referenced entity IDs.
  */
-type ViewSnapshot<T$1 extends Entity, S extends Selection<T$1>> = Readonly<{
+type ViewSnapshot<T extends Entity, S extends Selection<T>> = Readonly<{
   coverage: ReadonlyArray<readonly [id: EntityId, paths: ReadonlySet<string>]>;
-  data: ViewData<T$1, S>;
+  data: ViewData<T, S>;
 }>;
-type ConnectionMask<T$1 extends Entity, S> = S extends {
-  items: infer ItemSelection;
-  pagination?: infer PaginationSelection;
+type ConnectionLikeSelection = {
+  readonly items: {
+    readonly node: unknown;
+  };
+};
+type ConnectionMask<T extends Entity, S> = S extends {
+  readonly items: infer ItemSelection;
+  readonly pagination?: infer PaginationSelection;
 } ? {
   items: ItemSelection extends {
-    cursor?: infer CursorSelection;
-    node: unknown;
+    readonly cursor?: infer CursorSelection;
+    readonly node: unknown;
   } ? Array<(CursorSelection extends true ? {
     cursor: string;
   } : Record<string, never>) & {
-    node: ViewRef<T$1['__typename']>;
+    node: ViewRef<T['__typename']>;
   }> : Array<{
-    node: ViewRef<T$1['__typename']>;
+    node: ViewRef<T['__typename']>;
   }>;
 } & (PaginationSelection extends object ? {
   pagination: { [K in keyof PaginationSelection]: Pagination[K & keyof Pagination] };
-} : Record<string, never>) : Array<T$1>;
-type EntityName<T$1> = T$1 extends {
+} : Record<string, never>) : Array<T>;
+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$1, S> = T$1 extends Array<infer U extends Entity> ? S extends true ? Array<U> : S extends ConnectionSelection<U> ? ConnectionMask<U, S> : HasViewTag<S> extends true ? Array<ViewRef<U['__typename']>> : Array<Mask<U, S>> : S extends true ? T$1 : S extends object ? HasViewTag<S> extends true ? NonNullish<T$1> extends Entity ? ViewRef<EntityName<NonNullish<T$1>>> : ViewRef<EntityName<NonNullable<T$1>>> : { [K in keyof S as K extends 'args' ? never : K]: S[K] extends true ? NonNullish<T$1>[Extract<K, keyof T$1>] : Mask<NonNullish<T$1>[Extract<K, keyof T$1>], Extract<S[K], object>> } & (T$1 extends Entity ? Pick<NonNullish<T$1>, '__typename'> : Record<never, never>) : T$1;
-type Mask<T$1, S> = WithNullish<T$1, MaskNonNullish<NonNullish<T$1>, S>>;
+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 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;
 /** Name of the entity type captured from a view definition. */
@@ -1140,7 +1270,7 @@ type ConnectionNodeType<Root> = Root extends {
     node?: infer Node;
   };
 } ? ViewEntityName<Node & View<any, any>> : never;
-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 {
+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 {
   items?: {
     node?: View<any, any>;
   };
@@ -1155,28 +1285,28 @@ type ListResult<Item extends AnyRequestItem, Type extends TypeName, Result$1> =
  * The result of a `FateClient.request` and `useRequest` call, mapping each
  * request key to its corresponding result.
  */
-type RequestResult<R$1 extends FateRoots, Q extends AnyRequest> = { [K in keyof Q]: K extends keyof R$1 ? ListResult<Q[K], RootType<R$1[K]>, RootResult<R$1[K]>> : never };
+type RequestResult<R extends FateRoots, Q extends AnyRequest> = { [K in keyof Q]: K extends keyof R ? ListResult<Q[K], RootType<R[K]>, RootResult<R[K]>> : never };
 /** Brand used on root definitions to mark their identity in the d.ts output. */
 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$1> = Readonly<{
+type RootDefinition<Type extends TypeName, Result> = Readonly<{
   [RootKind]: true;
   type: Type;
-}> & __RootResultAnchor<Result$1> & __RootTypeAnchor<Type>;
+}> & __RootResultAnchor<Result> & __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. */
-type RootType<R$1> = R$1 extends __RootTypeAnchor<infer T> ? T : never;
+type RootType<R> = R extends __RootTypeAnchor<infer T> ? T : never;
 /** Extracts the result type from a root definition. */
-type RootResult<R$1> = R$1 extends __RootResultAnchor<infer Data> ? Data : never;
+type RootResult<R> = R extends __RootResultAnchor<infer Data> ? Data : never;
 /** Metadata describing a mutation for a particular entity, input, and output. */
-type MutationDefinition<T$1 extends Entity, I$1, R$1> = Readonly<{
-  entity: T$1['__typename'];
+type MutationDefinition<T extends Entity, I, R> = Readonly<{
+  entity: T['__typename'];
   [MutationKind]: true;
-}> & __MutationEntityAnchor<T$1> & __MutationInputAnchor<I$1> & __MutationResultAnchor<R$1>;
-type MutationIdentifier<T$1 extends Entity, I$1, R$1> = MutationDefinition<T$1, I$1, R$1> & Readonly<{
+}> & __MutationEntityAnchor<T> & __MutationInputAnchor<I> & __MutationResultAnchor<R>;
+type MutationIdentifier<T extends Entity, I, R> = MutationDefinition<T, I, R> & Readonly<{
   key: string;
 }>;
 /** Extracts the input type from a mutation definition or identifier. */
@@ -1198,18 +1328,18 @@ type MutationMapFromDefinitions<D extends FateMutations> = { [K in keyof D]: {
   input: MutationInput<D[K]>;
   output: MutationResult<D[K]>;
 } };
-type OptimisticUpdateValue<T$1> = T$1 extends ReadonlyArray<infer U> ? Array<OptimisticUpdateValue<U>> : NonNullish<T$1> extends AnyRecord ? OptimisticUpdate<NonNullish<T$1>> | Nullish<T$1> : NonNullish<T$1> | Nullish<T$1>;
+type OptimisticUpdateValue<T> = T extends ReadonlyArray<infer U> ? Array<OptimisticUpdateValue<U>> : NonNullish<T> extends AnyRecord ? OptimisticUpdate<NonNullish<T>> | Nullish<T> : NonNullish<T> | Nullish<T>;
 /** Shape used to describe optimistic updates for mutations. */
-type OptimisticUpdate<T$1> = { [K in keyof T$1]?: OptimisticUpdateValue<T$1[K]> };
+type OptimisticUpdate<T> = { [K in keyof T]?: OptimisticUpdateValue<T[K]> };
 /** Snapshot captured before mutating the cache, used to roll back on errors. */
 type Snapshot = Readonly<{
   mask?: FieldMask;
   record?: AnyRecord;
 }>;
 /** Promise-like value returned by cache reads that already have a resolved payload for React `use`. */
-interface FateThenable<T$1> extends PromiseLike<T$1> {
+interface FateThenable<T> extends PromiseLike<T> {
   status: 'fulfilled';
-  value: T$1;
+  value: T;
 }
 //#endregion
-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 };
+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 };