@nkzw/fate 1.4.0 → 1.5.0

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

@@ -555,368 +555,6 @@ interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
 }
 type AnyRouter = Router<any, any>;
 //#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 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);
-  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): (commit?: () => void) => void;
-  private getPendingOverlap;
-  private captureRecord;
-  private captureList;
-  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;
-}>;
-//#endregion
-//#region src/selection.d.ts
-/**
- * Representation of a composed selection including hashed args and the
- * flat set of field paths to read or fetch.
- */
-type SelectionPlan = {
-  readonly args: Map<string, Readonly<{
-    hash: string;
-    ignoreKeys?: ReadonlySet<string>;
-    value: AnyRecord;
-  }>>;
-  readonly live: Map<string, ConnectionLivePolicy>;
-  readonly paths: Set<string>;
-};
-/**
- * Flattens a view into a `SelectionPlan`, expanding composed views and
- * partitioning nested args so the client can fetch exactly what is declared.
- */
-declare const getSelectionPlan: <T extends Entity, S extends Selection<T>, V extends View<T, S>>(viewComposition: V, ref: ViewRef<T['__typename']> | null) => SelectionPlan;
-//#endregion
-//#region src/operation-lifetime.d.ts
-type RetainHandle = Readonly<{
-  dispose(): void;
-}>;
-//#endregion
-//#region src/client.d.ts
-/**
- * Strategy used when resolving a request.
- */
-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;
-}>;
-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;
-  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 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 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 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>, 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;
-  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
@@ -939,6 +577,8 @@ type MutationOptions<Identifier extends MutationIdentifier<any, any, any>> = {
   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>>>;
 };
@@ -980,6 +620,17 @@ 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]>>; }>;
+/** @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. */
@@ -1261,59 +912,584 @@ type ListResult<Item extends AnyRequestItem, Type extends TypeName, Result> = It
   pagination?: Pagination;
 }> : Array<ViewRef<Type>> : never;
 /**
- * The result of a `FateClient.request` and `useRequest` call, mapping each
- * request key to its corresponding result.
+ * 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; };
+/** 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> = Readonly<{
+  [RootKind]: true;
+  type: 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> = R extends __RootTypeAnchor<infer T> ? T : never;
+/** Extracts the result type from a root definition. */
+type RootResult<R> = R extends __RootResultAnchor<infer Data> ? Data : never;
+/** Metadata describing a mutation for a particular entity, input, and output. */
+type MutationDefinition<T extends Entity, I, R> = Readonly<{
+  entity: T['__typename'];
+  [MutationKind]: true;
+}> & __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. */
+type MutationInput<M> = M extends __MutationInputAnchor<infer I> ? I : never;
+/** Extracts the result type from a mutation definition or identifier. */
+type MutationResult<M> = M extends __MutationResultAnchor<infer R> ? R : never;
+/** Extracts the entity type from a mutation definition or identifier. */
+type MutationEntity<M> = M extends __MutationEntityAnchor<infer E> ? E : never;
+/** Minimal mutation description used for transport typing. */
+type MutationShape = {
+  input: unknown;
+  output: unknown;
+};
+/**
+ * Convenience helper that maps mutation definitions to their input/output
+ * shapes for use by transports.
+ */
+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]>; };
+/** 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/selection.d.ts
+/**
+ * Representation of a composed selection including hashed args and the
+ * flat set of field paths to read or fetch.
+ */
+type SelectionPlan = {
+  readonly args: Map<string, Readonly<{
+    hash: string;
+    ignoreKeys?: ReadonlySet<string>;
+    value: AnyRecord;
+  }>>;
+  readonly live: Map<string, ConnectionLivePolicy>;
+  readonly paths: Set<string>;
+};
+/**
+ * Flattens a view into a `SelectionPlan`, expanding composed views and
+ * partitioning nested args so the client can fetch exactly what is declared.
+ */
+declare const getSelectionPlan: <T extends Entity, S extends Selection<T>, V extends View<T, S>>(viewComposition: V, ref: ViewRef<T['__typename']> | null) => SelectionPlan;
+//#endregion
+//#region src/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 QueryRequestDescriptor = Readonly<{
+  argsPayload: ResolvedArgsPayload | undefined;
+  kind: 'query';
+  name: string;
+  plan: SelectionPlan;
+  queryKey: string;
+  refViewNames: ReadonlySet<string>;
+  type: string;
+  viewSignature: string;
+}>;
+type ListRequestDescriptor = Readonly<{
+  argsPayload: ResolvedArgsPayload | undefined;
+  hasItems: boolean;
+  kind: 'list';
+  listKey: string;
+  name: string;
+  nodeRefViewNames: ReadonlySet<string>;
+  plan: SelectionPlan;
+  type: string;
+  viewSignature: string;
+}>;
+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 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> = Readonly<{
-  [RootKind]: true;
-  type: 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> = R extends __RootTypeAnchor<infer T> ? T : never;
-/** Extracts the result type from a root definition. */
-type RootResult<R> = R extends __RootResultAnchor<infer Data> ? Data : never;
-/** Metadata describing a mutation for a particular entity, input, and output. */
-type MutationDefinition<T extends Entity, I, R> = Readonly<{
-  entity: T['__typename'];
-  [MutationKind]: true;
-}> & __MutationEntityAnchor<T> & __MutationInputAnchor<I> & __MutationResultAnchor<R>;
-type MutationIdentifier<T extends Entity, I, R> = MutationDefinition<T, I, R> & Readonly<{
-  key: string;
+type RequestOptions = Readonly<{
+  mode?: RequestMode;
+  /** Override disk retention in milliseconds; only used with persistence. */
+  persist?: {
+    maxAge: number;
+  };
 }>;
-/** Extracts the input type from a mutation definition or identifier. */
-type MutationInput<M> = M extends __MutationInputAnchor<infer I> ? I : never;
-/** Extracts the result type from a mutation definition or identifier. */
-type MutationResult<M> = M extends __MutationResultAnchor<infer R> ? R : never;
-/** Extracts the entity type from a mutation definition or identifier. */
-type MutationEntity<M> = M extends __MutationEntityAnchor<infer E> ? E : never;
-/** Minimal mutation description used for transport typing. */
-type MutationShape = {
-  input: unknown;
-  output: unknown;
+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'];
+  }>>;
 };
 /**
- * Convenience helper that maps mutation definitions to their input/output
- * shapes for use by transports.
+ * Core client that normalizes records, manages the view cache, and coordinates
+ * data fetching.
  */
-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]>; };
-/** 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;
+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
@@ -1373,6 +1549,11 @@ interface Transport<Mutations extends TransportMutations = EmptyTransportMutatio
   }>;
   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;
 }
@@ -1409,12 +1590,13 @@ type EmptyMutationResolvers<AppRouter extends AnyRouter> = Record<never, Mutatio
  * 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 { HydrationLimits as $, TypeConfig as A, __FateEntityBrand as B, MutationShape as C, RequestResult as D, Request$1 as E, ViewEntityName as F, DeferredSnapshot as G, isViewTag as H, ViewRef as I, RequestOptions as J, FateClient as K, ViewSelection as L, View as M, ViewData as N, RootDefinition as O, ViewEntity as P, HydrateOptions as Q, ViewSnapshot as R, MutationResult as S, Pagination as T, FateMutations as U, __FateSelectionBrand as V, mutation as W, getSelectionPlan as X, createClient as Y, FateDehydratedState as Z, Mask as _, ConnectionRef as a, MutationIdentifier as b, Deferred as c, DeferredTag as d, List as et, Entity as f, ListItem as g, FateThenable as h, ConnectionMetadata as i, TypeName as j, Selection as k, DeferredMetadata as l, FateRoots as m, createTRPCTransport as n, QueryProcedure as nt, ConnectionTag as o, EntityId as p, RequestMode as q, AnyRecord as r, DeferTag as s, Transport as t, AnyProcedure as tt, DeferredSelection as u, MutationDefinition as v, NodesItem as w, MutationInput as x, MutationEntity as y, ViewTag 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 };