@nkzw/fate 1.3.3 → 1.5.0

package/lib/{transport-DhaVVq4P.d.mts → transport-DqjhjLfC.d.mts}

@@ -1,6 +1,5 @@
 import { TRPCClient } from "@trpc/client";
-
-//#region ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@6.0.3/node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
+//#region ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@7.0.2/node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
 //#region src/observable/types.d.ts
 interface Unsubscribable {
   unsubscribe(): void;
@@ -24,7 +23,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.18.0_typescript@6.0.3/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-BdVSvUCr.d.mts
+//#region ../../node_modules/.pnpm/@trpc+server@11.18.0_typescript@7.0.2/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-BdVSvUCr.d.mts
 /**
  * @public
  */
@@ -75,10 +74,6 @@ declare const TRPC_ERROR_CODES_BY_KEY: {
 };
 type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
 type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;
-/**
- * tRPC error codes that are considered retryable
- * With out of the box SSE, the client will reconnect when these errors are encountered
- */
 declare class TRPCError extends Error {
   readonly cause?: Error;
   readonly code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
@@ -87,7 +82,7 @@ declare class TRPCError extends Error {
     code: TRPC_ERROR_CODE_KEY;
     cause?: unknown;
   });
-} //# sourceMappingURL=TRPCError.d.ts.map
+}
 //#endregion
 //#region src/vendor/standard-schema-v1/spec.d.ts
 /**
@@ -148,7 +143,7 @@ declare namespace StandardSchemaV1 {
   type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
   /** Infers the output type of a Standard Schema. */
   type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
-} //# sourceMappingURL=spec.d.ts.map
+}
 //#endregion
 //#region src/unstable-core-do-not-import/parser.d.ts
 type ParserZodEsque<TInput, TParsedInput> = {
@@ -198,7 +193,8 @@ interface ProcedureCallOptions<TContext> {
    * The index of this call in a batch request.
    */
   batchIndex: number;
-} //#endregion
+}
+//#endregion
 //#region src/unstable-core-do-not-import/procedure.d.ts
 declare const procedureTypes: readonly ["query", "mutation", "subscription"];
 /**
@@ -268,11 +264,7 @@ interface ErrorHandlerOptions<TContext> {
   path: string | undefined;
   input: unknown;
   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
 /**
@@ -283,10 +275,6 @@ interface TRPCErrorShape<TData extends object = object> {
   message: string;
   data: TData;
 }
-/**
- * JSON-RPC 2.0 Specification
- */
-//# sourceMappingURL=envelopes.d.ts.map
 //#endregion
 //#region src/unstable-core-do-not-import/transformer.d.ts
 /**
@@ -329,10 +317,6 @@ interface CombinedDataTransformer {
    */
   output: OutputDataTransformer;
 }
-/**
- * @public
- */
-//# sourceMappingURL=parseTRPCMessage.d.ts.map
 //#endregion
 //#region src/unstable-core-do-not-import/error/formatter.d.ts
 /**
@@ -390,11 +374,6 @@ interface JSONLProducerOptions {
    */
   pingMs?: number;
 }
-/**
- * JSON Lines stream producer
- * @see https://jsonlines.org/
- */
-//# sourceMappingURL=sse.types.d.ts.map
 //#endregion
 //#region src/unstable-core-do-not-import/stream/sse.d.ts
 type Serialize$1 = (value: any) => any;
@@ -445,10 +424,6 @@ interface SSEStreamProducerOptions<TValue = unknown> {
    */
   client?: SSEClientOptions;
 }
-/**
- *
- * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
- */
 //#endregion
 //#region src/unstable-core-do-not-import/rootConfig.d.ts
 /**
@@ -461,9 +436,6 @@ interface RootTypes {
   errorShape: DefaultErrorShape;
   transformer: boolean;
 }
-/**
- * The default check to see if we're in a server
- */
 /**
  * The tRPC root config
  * @internal
@@ -540,7 +512,7 @@ type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedure
 /**
  * @internal
  */
-type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never };
+type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends (infer $Value) ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never; };
 /**
  * @internal
  */
@@ -563,10 +535,6 @@ type LazyLoader<TAny> = {
   load: () => Promise<void>;
   ref: Lazy<TAny>;
 };
-/**
- * Lazy load a router
- * @see https://trpc.io/docs/server/merging-routers#lazy-load
- */
 /**
  * @internal
  */
@@ -587,421 +555,82 @@ interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
 }
 type AnyRouter = Router<any, any>;
 //#endregion
-//#region src/mask.d.ts
-type FieldMask = {
-  all: boolean;
-  children: Map<string, FieldMask>;
-};
-//#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;
-  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>;
-}>;
-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;
-  private listKeysByReferencedEntity;
-  private lists;
-  private recordReferenceFields;
-  private recordReferencesByTarget;
-  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;
-  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/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
+//#region src/mutation.d.ts
 /**
- * Representation of a composed selection including hashed args and the
- * flat set of field paths to read or fetch.
+ * Defines a mutation for a given entity type, preserving the input and output
+ * types for transports.
  */
-type SelectionPlan = {
-  readonly args: Map<string, Readonly<{
-    hash: string;
-    ignoreKeys?: ReadonlySet<string>;
-    value: AnyRecord;
-  }>>;
-  readonly live: Map<string, ConnectionLivePolicy>;
-  readonly paths: Set<string>;
+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';
+/**
+ * Options accepted by a mutation invocation, including optimistic updates and
+ * 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. */
+  input: Omit<MutationInput<Identifier>, 'select'>;
+  insert?: InsertPosition;
+  /** Optional optimistic update to apply immediately. */
+  optimistic?: OptimisticUpdate<MutationResult<Identifier>>;
+  /** Skip durable delivery for this call, even when persistence is configured. */
+  persist?: boolean;
+  /** Optional view specifying which fields to select from the server. */
+  view?: View<MutationEntity<Identifier>, Selection<MutationEntity<Identifier>>>;
 };
 /**
- * Flattens a view into a `SelectionPlan`, expanding composed views and
- * partitioning nested args so the client can fetch exactly what is declared.
+ * Callable mutation entry point returned on the client that resolves to either
+ * a successful result or an error.
  */
-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;
+type MutationFunction<I extends MutationIdentifier<any, any, any>> = (options: MutationOptions<I>) => Promise<{
+  error: undefined;
+  result: MutationResult<I>;
+} | {
+  error: Error;
+  result: undefined;
 }>;
-//#endregion
-//#region src/client.d.ts
 /**
- * Strategy used when resolving a request.
+ * React action-compatible wrapper that can be passed directly to form actions
+ * or transitions.
  */
-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 MutationAction<I extends MutationIdentifier<any, any, any>> = (previousState: unknown,
 /**
- * Request options that affect how requests are fetched and retained.
+ * Mutation options or 'reset' to reset the action state.
  */
-type RequestOptions = Readonly<{
-  mode?: RequestMode;
-}>;
-type DeferredSnapshot<T> = Readonly<{
-  coverage: ReadonlyArray<readonly [id: EntityId, paths: ReadonlySet<string>]>;
-  data: T;
+options: MutationOptions<I> | 'reset') => Promise<{
+  error: undefined;
+  result: MutationResult<I>;
+} | {
+  error: Error;
+  result: undefined;
 }>;
-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.
-   *
-   * @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;
-  transport: Transport<MutationMapFromDefinitions<Mutations>>;
-  types: ReadonlyArray<Omit<TypeConfig, 'getId'> & Partial<{
-    getId: TypeConfig['getId'];
-  }>>;
-};
+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> = (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; };
 /**
- * Core client that normalizes records, manages the view cache, and coordinates
- * data fetching.
- */
-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;
-  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;
-  private pendingNetworkRequests;
-  readonly store: Store;
-  private readonly operationLifetime;
-  private readonly hydrationLimits;
-  private readonly hydrationScope;
-  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, 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;
-  private insertIntoRootLists;
-  getTypeConfig(type: string): TypeConfig;
-  private getListNodeType;
-  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, 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;
-  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 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;
-  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;
-  registerOptimisticUpdate(entityId: EntityId | null, select: ReadonlySet<string>): number | null;
-  clearOptimisticUpdate(token: number | null): void;
-  getPendingOptimisticMask(entityId: EntityId | null, options?: {
-    excludeToken?: number | null;
-  }): FieldMask | null;
-  private getPendingOptimisticMutations;
-  filterSelectionForPendingOptimistics(entityId: EntityId | null, select: Set<string>, options?: {
-    excludeToken?: number | null;
-  }): Set<string>;
-  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>;
-  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<{
-    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 hasPendingRequests;
-  trackPendingRequest<T>(request: () => Promise<T>): Promise<T>;
-  private runPendingGarbageCollection;
-  private handleStoreAndNetworkRequest;
-  private getRootType;
-  private createRequestDescriptor;
-  getRequestKey(request: Request$1): string;
-  private hasRootListData;
-  private executeRequest;
-  private hasRequestData;
-  getRequestResult<R extends Request$1>(request: R): RequestResult<Roots, R>;
-  private getRequestResultFromDescriptor;
-  private fetchByIdAndNormalize;
-  private fetchQueryAndNormalize;
-  private fetchListAndNormalize;
-  private writeEntity;
-  private linkParentLists;
-  private readViewSelection;
-  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>>], HydrationScope extends string = string>(options: FateClientOptions<T[0], T[1], HydrationScope>): FateClient<T[0], T[1], HydrationScope>;
-//#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 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';
-/**
- * Options accepted by a mutation invocation, including optimistic updates and
- * 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. */
-  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. */
-  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 extends MutationIdentifier<any, any, any>> = (options: MutationOptions<I>) => Promise<{
-  error: undefined;
-  result: MutationResult<I>;
-} | {
-  error: Error;
-  result: undefined;
-}>;
-/**
- * React action-compatible wrapper that can be passed directly to form actions
- * or transitions.
- */
-type MutationAction<I extends MutationIdentifier<any, any, any>> = (previousState: unknown,
-/**
- * Mutation options or 'reset' to reset the action state.
- */
-
-options: MutationOptions<I> | 'reset') => Promise<{
-  error: undefined;
-  result: MutationResult<I>;
-} | {
-  error: Error;
-  result: undefined;
-}>;
-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> = (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.
+ * Base type for client mutations.
  */
 type FateMutations = Record<string, MutationDefinition<any, any, any>>;
-type MutationTreeFromRecord<Mutations extends FateMutations, ValueMap extends Record<string, unknown>> = [keyof Mutations] extends [never] ? object : UnionToIntersection<{ [K in keyof Mutations & string]: NestedValue<K, ValueMap[K]> }[keyof Mutations & string]>;
-type MutationFunctionsFor<Mutations extends FateMutations> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationFunction<MutationIdentifierFor<K, Mutations[K]>> }>;
-type MutationActionsFor<Mutations extends FateMutations> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationAction<MutationIdentifierFor<K, Mutations[K]>> }>;
+type MutationTreeFromRecord<Mutations extends FateMutations, ValueMap extends Record<string, unknown>> = [keyof Mutations] extends [never] ? object : UnionToIntersection<{ [K in keyof Mutations & string]: NestedValue<K, ValueMap[K]>; }[keyof Mutations & string]>;
+type MutationFunctionsFor<Mutations extends FateMutations> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationFunction<MutationIdentifierFor<K, Mutations[K]>>; }>;
+type MutationActionsFor<Mutations extends FateMutations> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationAction<MutationIdentifierFor<K, Mutations[K]>>; }>;
+/** @internal Serializable input to a live or restored mutation. */
+type MutationCommand = {
+  args?: AnyRecord;
+  delete?: boolean;
+  entity: string;
+  input: AnyRecord;
+  insert: InsertPosition;
+  key: string;
+  optimistic?: AnyRecord;
+  plan?: SelectionPlan;
+};
 //#endregion
 //#region src/types.d.ts
 /** Canonical runtime name for an entity type as returned by the server. */
@@ -1086,9 +715,15 @@ 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. */
@@ -1135,7 +770,7 @@ 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> = { [K in keyof T]?: PlainObjectSelectionField<T[K]> };
+type PlainObjectSelection<T> = { [K in keyof T]?: PlainObjectSelectionField<T[K]>; };
 type ConnectionSelectionBase<T extends Entity> = Readonly<{
   items: Readonly<{
     cursor?: true;
@@ -1154,13 +789,13 @@ type ConnectionSelection<T extends Entity> = ConnectionSelectionBase<T> | (Selec
 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 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> } & {
+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<{
   select: Selection<T>;
   [ViewKind]: true;
-}> };
+}>; };
 /** Declarative selection of the fields a view needs from an entity. */
 type Selection<T extends Entity> = SelectionShape<T> & SelectionViewSpread<T>;
 /** View payload stored on a view tag containing the raw selection used to mask data. */
@@ -1172,7 +807,7 @@ type ViewPayload<T extends Entity, S extends Selection<T> = Selection<T>> = Read
 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 {
+type HasViewTag<S> = S extends { [K in ViewTag]?: infer P; } ? P extends {
   [ViewKind]: true;
 } ? true : false : false;
 /**
@@ -1210,13 +845,13 @@ type ConnectionMask<T extends Entity, S> = S extends {
     node: ViewRef<T['__typename']>;
   }>;
 } & (PaginationSelection extends object ? {
-  pagination: { [K in keyof PaginationSelection]: Pagination[K & keyof Pagination] };
+  pagination: { [K in keyof PaginationSelection]: Pagination[K & keyof Pagination]; };
 } : 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, 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 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;
@@ -1280,7 +915,7 @@ type ListResult<Item extends AnyRequestItem, Type extends TypeName, Result> = It
  * The result of a `FateClient.request` and `useRequest` call, mapping each
  * request key to its corresponding result.
  */
-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 };
+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. */
@@ -1322,78 +957,603 @@ type MutationShape = {
 type MutationMapFromDefinitions<D extends FateMutations> = { [K in keyof D]: {
   input: MutationInput<D[K]>;
   output: MutationResult<D[K]>;
-} };
+}; };
 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> = { [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;
-}>;
+type OptimisticUpdate<T> = { [K in keyof T]?: OptimisticUpdateValue<T[K]>; };
 /** Promise-like value returned by cache reads that already have a resolved payload for React `use`. */
 interface FateThenable<T> extends PromiseLike<T> {
   status: 'fulfilled';
   value: T;
 }
 //#endregion
-//#region src/transport.d.ts
+//#region src/selection.d.ts
 /**
- * Normalized representation of args passed to a transport.
+ * Representation of a composed selection including hashed args and the
+ * flat set of field paths to read or fetch.
  */
-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 SelectionPlan = {
+  readonly args: Map<string, Readonly<{
+    hash: string;
+    ignoreKeys?: ReadonlySet<string>;
+    value: AnyRecord;
+  }>>;
+  readonly live: Map<string, ConnectionLivePolicy>;
+  readonly paths: Set<string>;
 };
-type LiveEventHandlers = Readonly<{
-  onData: (record: unknown, select?: ReadonlyArray<string>) => void;
-  onDelete?: (id?: string | number) => void;
-  onError?: (error: unknown) => void;
+/**
+ * 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/request-descriptor.d.ts
+type NodeRequestDescriptor = Readonly<{
+  ids: ReadonlyArray<string | number>;
+  kind: 'node' | 'nodes';
+  name: string;
+  plan: SelectionPlan;
+  refViewNames: ReadonlySet<string>;
+  type: string;
+  viewSignature: string;
 }>;
-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 QueryRequestDescriptor = Readonly<{
+  argsPayload: ResolvedArgsPayload | undefined;
+  kind: 'query';
+  name: string;
+  plan: SelectionPlan;
+  queryKey: string;
+  refViewNames: ReadonlySet<string>;
+  type: string;
+  viewSignature: string;
 }>;
-type LiveConnectionEventHandlers = Readonly<{
-  onError?: (error: unknown) => void;
-  onEvent: (event: LiveConnectionEvent) => void;
+type ListRequestDescriptor = Readonly<{
+  argsPayload: ResolvedArgsPayload | undefined;
+  hasItems: boolean;
+  kind: 'list';
+  listKey: string;
+  name: string;
+  nodeRefViewNames: ReadonlySet<string>;
+  plan: SelectionPlan;
+  type: string;
+  viewSignature: string;
 }>;
-/**
- * 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']>;
+type RequestItemDescriptor = NodeRequestDescriptor | QueryRequestDescriptor | ListRequestDescriptor;
+type RequestDescriptor = Readonly<{
+  items: ReadonlyArray<RequestItemDescriptor>;
+  key: string;
+}>;
+//#endregion
+//#region src/cache.d.ts
+declare class ViewDataCache {
+  private readonly isEnabled;
+  constructor(isEnabled?: () => boolean);
+  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;
+  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>;
+}>;
+type StoreHydrationState = Readonly<{
+  coverage: ReadonlyArray<readonly [EntityId, ReadonlyArray<string>]>;
+  lists: ReadonlyArray<readonly [string, List]>;
+  records: ReadonlyArray<readonly [EntityId, AnyRecord]>;
+}>;
+declare class Store {
+  private readonly onRebase?;
+  private readonly onChange?;
+  private coverage;
+  private listKeysByOwnerField;
+  private listKeysByReferencedEntity;
+  private lists;
+  private recordReferenceFields;
+  private recordReferencesByTarget;
+  private records;
+  private subscriptions;
+  private listSubscriptions;
+  private readonly optimisticLayers;
+  private readonly optimisticBase;
+  private recordingLayer;
+  private rebase;
+  constructor(onRebase?: ((ids: ReadonlySet<EntityId>) => void) | undefined, onChange?: ((kind: 'record' | 'list', key: string, paths?: Iterable<string>, previousList?: List) => void) | undefined);
+  get hasOptimisticUpdates(): boolean;
+  get isRebasing(): boolean;
+  /** Apply a synchronous cache update beneath the pending optimistic layers. */
+  update<T>(apply: () => T): T;
+  private getRebaseChanges;
+  /** Returns an idempotent settlement function; omit its update to roll back. */
+  optimisticUpdate(apply: () => void, durable?: boolean): (commit?: () => void) => void;
+  private getPendingOverlap;
+  private captureRecord;
+  private captureList;
+  get hasTransientOptimisticUpdates(): boolean;
+  getOptimisticRoots(): {
+    baseRecords: AnyRecord[];
+    lists: string[];
+    records: string[];
+  };
+  /** @internal Indexed owners needed for mutation rollback. */
+  getPersistenceOwners(id: EntityId): {
+    lists: string[];
+    records: string[];
+  };
+  /** @internal Read one confirmed record without copying the cache. */
+  readConfirmed(id: EntityId): {
+    paths: string[];
+    record: AnyRecord;
+  } | undefined;
+  /** @internal */
+  readConfirmedList(key: string): 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;
+  dehydrateConfirmed(): StoreHydrationState;
+  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;
+  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): void;
+  private restore;
+  private addListIndexes;
+  private removeListIndexes;
+  private getListReferencedEntityIds;
+  private getRecordFieldReferences;
+  private addRecordFieldReferenceIndex;
+  private removeRecordFieldReferenceIndex;
+  private addRecordReferenceIndexes;
+  private removeRecordReferenceIndexes;
+  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;
+}>;
+type ClientHydrationState = Readonly<{
+  rootLists: ReadonlyArray<readonly [string, ReadonlyArray<string>]>;
+  rootRequests: ReadonlyArray<readonly [string, string | null]>;
+  store: StoreHydrationState;
+}>;
+declare const encodeHydrationValue: (value: unknown, limits?: Partial<HydrationLimits>) => FateSerializedValue;
+//#endregion
+//#region src/operation-lifetime.d.ts
+type RetainHandle = Readonly<{
+  dispose(): void;
+}>;
+//#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';
+/**
+ * Request options that affect how requests are fetched and retained.
+ */
+type RequestOptions = Readonly<{
+  mode?: RequestMode;
+  /** Override disk retention in milliseconds; only used with persistence. */
+  persist?: {
+    maxAge: number;
+  };
+}>;
+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.
+   *
+   * @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;
+  persistence?: Persistence;
+  roots: Roots;
+  transport: Transport<MutationMapFromDefinitions<Mutations>>;
+  types: ReadonlyArray<Omit<TypeConfig, 'getId'> & Partial<{
+    getId: TypeConfig['getId'];
+  }>>;
+};
+/**
+ * Core client that normalizes records, manages the view cache, and coordinates
+ * data fetching.
+ */
+declare class FateClient<Roots extends FateRoots, Mutations extends FateMutations, HydrationScope extends string = string> {
+  private readonly mutationEntities?;
+  private readonly mutationMap;
+  private readonly parentLists;
+  private readonly rootLists;
+  private readonly pending;
+  private readonly pendingDeferred;
+  private readonly pendingOptimisticMutations;
+  private readonly optimisticEntityResolutions;
+  private readonly onLiveError;
+  private readonly liveSubscriptions;
+  private readonly liveConnectionInvalidations;
+  private readonly stableRefs;
+  private readonly requests;
+  private readonly requestExecutionOptions;
+  private readonly rootRequests;
+  private readonly stalledRequests;
+  private gcPending;
+  private gcScheduled;
+  private pendingNetworkRequests;
+  private readonly persistenceDisposal?;
+  readonly store: Store;
+  private readonly operationLifetime;
+  private readonly hydrationLimits;
+  private readonly hydrationScope;
+  private readonly types;
+  private readonly transport;
+  private readonly viewDataCache;
+  private liveConnectionInvalidationToken;
+  readonly persistence?: PersistenceSession;
+  readonly actions: MutationActionsFor<Mutations>;
+  readonly mutations: MutationFunctionsFor<Mutations>;
+  readonly roots: Roots;
+  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;
+  /** @internal */
+  exportPersistenceState(): FateDehydratedState<HydrationScope>;
+  /** @internal */
+  retainPersistenceRequest(request: RequestDescriptor): Readonly<{
+    dispose(): void;
+  }>;
+  /** @internal */
+  getPersistenceScope(): HydrationScope;
+  /** @internal */
+  getPersistenceRootLists(type: string): Set<string>;
+  /** @internal */
+  getPersistenceQuery(key: string): string | null | undefined;
+  /** @internal Merge a small disk read beneath optimistic layers. */
+  restorePersistenceData(state: ClientHydrationState): void;
+  /** @internal */
+  getRetainedRequests(): readonly Readonly<{
+    items: ReadonlyArray<RequestItemDescriptor>;
+    key: string;
+  }>[];
+  /** @internal */
+  restoreRetainedRequests(requests: ReadonlyArray<RequestDescriptor>): void;
+  /** @internal */
+  hasMutation(key: string, entity: string): boolean;
+  private registerRootList;
+  private applyListInsert;
+  private insertIntoRootLists;
+  getTypeConfig(type: string): TypeConfig;
+  private getListNodeType;
+  /** @internal Validates local wiring without requiring network connectivity. */
+  validatePersistence(): void;
+  /** @internal */
+  assertPersistenceActive(): void;
+  /** @internal */
+  disposePersistence(): void;
+  private requireDurableMutationTransport;
+  executeMutation(key: string, input: unknown, select: Set<string>, options?: {
+    args?: AnyRecord;
+    identity?: MutationIdentity;
+    plan?: SelectionPlan;
+  }): Promise<unknown>;
+  write(type: string, data: AnyRecord, select: ReadonlySet<string>, plan?: SelectionPlan, insert?: InsertPosition): string;
+  deleteRecord(type: string, id: string | number): void;
+  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 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;
+  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;
+  private getPendingOptimisticMutations;
+  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>;
+  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<{
+    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 hasPendingRequests;
+  /** @internal */
+  withPersistenceLifecycle<T>(request: () => Promise<T>): Promise<T>;
+  trackPendingRequest<T>(request: () => Promise<T>): Promise<T>;
+  private runPendingGarbageCollection;
+  private handleStoreAndNetworkRequest;
+  private getRootType;
+  private createRequestDescriptor;
+  getRequestKey(request: Request$1): string;
+  private hasRootListData;
+  private executeRequest;
+  private hasRequestData;
+  getRequestResult<R extends Request$1>(request: R): RequestResult<Roots, R>;
+  private getRequestResultFromDescriptor;
+  private fetchByIdAndNormalize;
+  private fetchQueryAndNormalize;
+  private fetchListAndNormalize;
+  private writeEntity;
+  private linkParentLists;
+  private readViewSelection;
+  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>>], HydrationScope extends string = string>(options: FateClientOptions<T[0], T[1], HydrationScope>): FateClient<T[0], T[1], HydrationScope>;
+//#endregion
+//#region src/persistence-types.d.ts
+/** Identity of one logical mutation, reused across every delivery attempt. */
+type MutationIdentity = Readonly<{
+  id: string;
+  replayOnly?: true;
+  /** Return an existing receipt; never execute a new mutation. */ scope: string;
+}>;
+/** A persistence integration. Implementations are imported separately from Fate core. */
+interface Persistence {
+  attach(client: FateClient<any, any, any>): PersistenceSession;
+}
+type PersistedMutationStatus = Readonly<{
+  error?: string;
+  id: string;
+  input: unknown;
+  name: string;
+  status: 'queued' | 'sending' | 'failed';
+}>;
+type PersistenceSnapshot = Readonly<{
+  error?: Error;
+  mutations: ReadonlyArray<PersistedMutationStatus>;
+  status: 'restoring' | 'ready' | 'error' | 'disposed';
+}>;
+type RequestPersistenceOptions = Readonly<{
+  maxAge: number;
+}>;
+/** Observability and lifecycle of an attached persistence integration. */
+interface PersistenceSession {
+  /** @internal */
+  changed(kind?: 'record' | 'list', key?: string, paths?: Iterable<string>, previousList?: List): void;
+  clearCache(): Promise<void>;
+  discard(id: string): Promise<void>;
+  dispose(): void;
+  /** @internal */
+  fetched(request: RequestDescriptor, options?: RequestPersistenceOptions): void;
+  flush(): Promise<void>;
+  getSnapshot(): PersistenceSnapshot;
+  /** @internal */
+  mutate(command: MutationCommand): Promise<unknown>;
+  readonly ready: Promise<void>;
+  /** @internal */
+  restoreRequest(request: RequestDescriptor): Promise<void>;
+  retry(): void;
+  subscribe(listener: () => void): () => void;
+  /** @internal */
+  used(request: RequestDescriptor, options?: RequestPersistenceOptions): void;
+}
+//#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;
+};
+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']>;
+  /**
+   * Deliver through an endpoint that durably deduplicates this identity. Required
+   * for persisted mutations; never falls back to ordinary mutate.
+   */
+  mutateDurably?<K extends Extract<keyof Mutations, string>>(proc: K, input: Mutations[K]['input'], select: Set<string>, identity: MutationIdentity): 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;
 }
@@ -1424,24 +1584,19 @@ type TRPCMutationResolvers<AppRouter extends AnyRouter> = Record<string, Mutatio
 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 };
+} : 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
-}: {
+declare function createTRPCTransport<AppRouter extends AnyRouter, Mutations extends TRPCMutationResolvers<AppRouter> = EmptyMutationResolvers<AppRouter>>({ byId, client, lists, mutateDurably, mutations, queries }: {
   byId: TRPCByIdResolvers<AppRouter>;
   client: TRPCClient<AppRouter>;
   lists?: TRPCListResolvers<AppRouter>;
+  mutateDurably?: Transport<MutationMapFromResolvers<Mutations>>['mutateDurably'];
   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 };
+export { ViewSnapshot as $, FateThenable as A, Pagination as B, Deferred as C, Entity as D, DeferredTag as E, MutationIdentifier as F, TypeConfig as G, RequestResult as H, MutationInput as I, ViewData as J, TypeName as K, MutationResult as L, Mask as M, MutationDefinition as N, EntityId as O, MutationEntity as P, ViewSelection as Q, MutationShape as R, DeferTag as S, DeferredSelection as T, RootDefinition as U, Request$1 as V, Selection as W, ViewEntityName as X, ViewEntity as Y, ViewRef as Z, getSelectionPlan as _, PersistenceSession as a, mutation as at, ConnectionRef as b, FateClient as c, createClient as d, ViewTag as et, FateDehydratedState as f, List as g, encodeHydrationValue as h, Persistence as i, FateMutations as it, ListItem as j, FateRoots as k, RequestMode as l, HydrationLimits as m, createTRPCTransport as n, __FateSelectionBrand as nt, PersistenceSnapshot as o, AnyProcedure as ot, HydrateOptions as p, View as q, MutationIdentity as r, isViewTag as rt, DeferredSnapshot as s, QueryProcedure as st, Transport as t, __FateEntityBrand as tt, RequestOptions as u, AnyRecord as v, DeferredMetadata as w, ConnectionTag as x, ConnectionMetadata as y, NodesItem as z };