@tanstack/solid-query 6.0.0-rc.0 → 6.0.0-rc.2

package/README.md

@@ -1,6 +1,20 @@
 <img src="https://static.scarf.sh/a.png?x-pxid=be2d8a11-9712-4c1d-9963-580b2d4fb133" />
 
-![TanStack Query Header](https://github.com/TanStack/query/raw/main/media/repo-header.png)
+<picture>
+  <source
+    media="(prefers-color-scheme: dark)"
+    srcset="https://tanstack.com/api/readme/query.png?framework=solid&theme=dark"
+  />
+  <source
+    media="(prefers-color-scheme: light)"
+    srcset="https://tanstack.com/api/readme/query.png?framework=solid"
+  />
+  <img
+    src="https://tanstack.com/api/readme/query.png?framework=solid"
+    alt="TanStack Solid Query"
+    width="900"
+  />
+</picture>
 
 Hooks for fetching, caching and updating asynchronous data in Solid
 

package/build/_tsup-dts-rollup.d.cts

@@ -143,54 +143,55 @@ import { WithRequired } from '@tanstack/query-core';
 
 export { AnyDataTag }
 
+/** Internal seam: everything the read layer builds, for hooks that extend
+ * the base result (`useInfiniteQuery` pagers ride the same entry). */
+declare interface BaseQueryLayer<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey> {
+    result: UseBaseQueryResult<TData, TError>;
+    observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    /** Version-tracked: reading it subscribes to this query's cache events. */
+    query: () => Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    defaultedOptions: Accessor<ReturnType<QueryClient['defaultQueryOptions']>>;
+    isFetching: () => boolean;
+    status: () => 'pending' | 'error' | 'success';
+}
+
 export { CancelledError }
 
 export { CancelOptions }
 
 /**
- * Client side of the channel. Created by `QueryClientProvider` on the
- * client and handed to `useBaseQuery` via context so hydrated components
- * can attach their observers as soon as their query's entry has been
- * primed — per query, not at global hydration end, which keeps
- * early-hydrated components live while other boundaries still stream.
- */
-export declare function createHydrationCoordinator(client: () => QueryClient): HydrationCoordinator;
-
-export declare const createInfiniteQuery: typeof useInfiniteQuery;
-
-export declare const createMutation: typeof useMutation;
-
-export declare const createQueries: typeof useQueries;
-
-export declare const createQuery: typeof useQuery;
-
-/**
- * Server side of the library-owned serialization channel.
+ * Shared reactive core for the cross-cache aggregate hooks — `useIsFetching`,
+ * `useIsMutating`, `useMutationState` — which all reduce to "a value derived
+ * from a whole cache, refreshed on its events". Two invariants live here so
+ * each hook doesn't restate them:
  *
- * Returns an AsyncIterable that yields a cumulative snapshot of the
- * dehydrated query cache (success entries, per query-core `dehydrate()`
- * shapes) every time a query settles during SSR. `QueryClientProvider`
- * holds it as a signal value, so Solid serializes it through the normal
- * per-computation path: the server runtime tees the iterator into the
- * hydration serializer (`ctx.serialize(id, tapped)` in solid-js'
- * `processResult`) and seroval streams each yield to the client as a
- * script chunk riding the SSR stream.
+ * Dual write. Cache events can fire inside an action transaction
+ * (`useMutation` rides core `action`; an onSuccess invalidation dispatches
+ * refetches mid-action), where a plain signal write is held until settle —
+ * the in-flight value would be invisible. An optimistic override alone fails
+ * the other way: outside a transaction, overrides drop at batch end. So a
+ * durable signal carries committed state and an optimistic node tracks it as
+ * its base; in-transaction values surface through the override, and the held
+ * durable write becomes the base when the settle lands.
  *
- * The iterable must terminate for the SSR stream to complete: the
- * hydration serializer's `flush()` only fires its `onDone` once all
- * pending streams have closed, and the render root is disposed *after*
- * that, so neither `onCleanup` nor the serializer itself can close the
- * channel. Instead the channel closes itself on cache quiescence: after
- * every cache event (and once at creation) it schedules a timer-task
- * check; if no query is fetching by then, no further settle can occur —
- * suspense retry passes that start waterfall fetches are scheduled on
- * microtasks, so they have begun before the check runs — and the channel
- * emits its final cumulative snapshot with `done: true` and completes.
+ * Hydration. A cross-cache aggregate is not tied to a single async source,
+ * so it cannot ride the boundary contract per-query meta uses (suspend until
+ * settled). Its contract is fixed by construction instead: a hydrating
+ * client can only ever observe the empty value at claim time — its own
+ * fetches are held inside the hydration window, channel-primed entries are
+ * settled, and mutations do not transfer across SSR. So the server
+ * serializes the empty value, and a hydrated mount latches there until its
+ * window closes: the subscription and first sync run from an effect half,
+ * deferred past hydration — the earliest globally-safe moment for a
+ * cross-cache read to go live (on a streamed page, an already-hydrated
+ * region's refetch can be in flight while this region is still claiming).
  *
- * Single-consumer by design: solid-js creates exactly one iterator from
- * the value and shares it between the memo and the serializer tap.
+ * Every node here is created on the server too, where it is never read or
+ * written: hydration id assignment is positional, so both sides must create
+ * the same reactive nodes or every id downstream shifts and the subtree
+ * key-misses.
  */
-export declare function createServerDehydrationChannel(client: QueryClient): AsyncIterable<DehydrationChannelYield>;
+export declare function createCacheAggregate<T>(subscribe: (onEvent: () => void) => () => void, read: (prev: T) => T, empty: T): Accessor<T>;
 
 export { DataTag }
 
@@ -232,56 +233,50 @@ export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }
 
 export { DefinedQueryObserverResult }
 
-declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
-export { DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult }
+declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = OmitIsInitialLoading<DefinedQueryObserverResult<TData, TError>>;
 export { DefinedUseBaseQueryResult }
 export { DefinedUseBaseQueryResult as DefinedUseBaseQueryResult_alias_1 }
 
-declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
-export { DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult }
+declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = OmitIsInitialLoading<DefinedInfiniteQueryObserverResult<TData, TError>>;
 export { DefinedUseInfiniteQueryResult }
 export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }
 
 declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
-export { DefinedUseQueryResult as DefinedCreateQueryResult }
 export { DefinedUseQueryResult }
 export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
 
 export { dehydrate }
 
-declare type DehydratedQueryEntry = DehydratedState['queries'][number];
-
 export { DehydratedState }
 
 export { DehydrateOptions }
 
 /**
- * A single message on the dehydration channel. `entries` is *cumulative* —
- * every yield carries all entries settled so far. Two reasons:
+ * Waits for every fetch the client has in flight to settle, then
+ * dehydrates. This is the extraction half of a single-flight collector:
+ * after route data functions run for the mutation's target URL, loaders
+ * commonly kick off prefetches without awaiting them — plain
+ * `dehydrate()` would snapshot those mid-fetch and ship nothing.
  *
- * - It is what makes Solid's signal-path hydration replay lossless.
- *   Yields still buffered when hydration begins are conflated to the
- *   LATEST one (`normalizeIterator` drains synchronously available
- *   results, keeps the last data yield, and delivers the stream's done
- *   result on a subsequent pull), so each yield must be self-contained:
- *   the latest cumulative snapshot alone carries everything the dropped
- *   intermediates did. Requires the solid-js build with that conflation
- *   behavior (> 2.0.0-beta.32); earlier betas pinned the replay at the
- *   FIRST buffered yield, dropping every later entry and the `done`
- *   marker.
- * - Entry objects keep their identity across yields, so seroval's
- *   cross-reference serialization emits each entry once and later yields
- *   only reference it — the cumulative shape costs bytes proportional to
- *   the number of entries, not its square.
+ * ```ts
+ * registerFlightDataSource(FLIGHT_DATA_SOURCE, (event, outcome) =>
+ *   loadFlightTarget({
+ *     router,
+ *     event,
+ *     outcome,
+ *     collect: () => dehydrateSettled(queryClient),
+ *   }),
+ * )
+ * ```
  *
- * `done: true` marks the final yield. The client uses it to release
- * subscribers still waiting for entries that will never arrive (e.g.
- * queries that errored during SSR and were not dehydrated).
+ * Settling is chased to quiescence — awaiting one batch of fetches can
+ * dispatch more (dependent queries keyed off a first result) — so an
+ * unconditionally self-refetching query would keep this pending; that's
+ * an app bug mirrored, not guarded.
  */
-export declare interface DehydrationChannelYield {
-    entries: Array<DehydratedQueryEntry>;
-    done: boolean;
-}
+declare function dehydrateSettled(client: QueryClient, options?: DehydrateOptions): Promise<DehydratedState>;
+export { dehydrateSettled }
+export { dehydrateSettled as dehydrateSettled_alias_1 }
 
 export { DistributiveOmit }
 
@@ -303,6 +298,31 @@ export { FetchQueryOptions }
 
 export { FetchStatus }
 
+/**
+ * The query cache's single-flight source id. Mutation responses can fold
+ * fresh data for multiple caches at once (Solid's multi-source
+ * single-flight protocol); this is the slice the query cache claims — the
+ * provider subscribes its consumer under it, and server collectors
+ * register under it to produce the data:
+ *
+ * ```ts
+ * import { registerFlightDataSource } from '@solidjs/web/server-functions/server'
+ * import { FLIGHT_DATA_SOURCE, dehydrate } from '@tanstack/solid-query'
+ *
+ * registerFlightDataSource(FLIGHT_DATA_SOURCE, async (event, outcome) => {
+ *   // rebuild the data for outcome.targetUrl into a QueryClient, then
+ *   return dehydrate(queryClient)
+ * })
+ * ```
+ *
+ * The slice's payload is a `DehydratedState`; the provider consumes it
+ * with `hydrate()`, so every mounted query on those keys updates before
+ * the mutation's promise resolves — no follow-up refetches.
+ */
+declare const FLIGHT_DATA_SOURCE = "sq";
+export { FLIGHT_DATA_SOURCE }
+export { FLIGHT_DATA_SOURCE as FLIGHT_DATA_SOURCE_alias_1 }
+
 export { focusManager }
 
 export { GetNextPageParamFunction }
@@ -347,23 +367,13 @@ export { hydrate }
 
 export { HydrateOptions }
 
-declare interface HydrationCoordinator {
-    /**
-     * Prime the QueryClient from a channel yield. Entries already applied
-     * (same queryHash and dataUpdatedAt) are skipped; the rest go through
-     * query-core `hydrate()`, which keeps whichever data is newer.
-     */
-    applyYield: (value: DehydrationChannelYield) => void;
-    /**
-     * Invoke `callback` (on a microtask) once the entry for `queryHash` has
-     * been applied — or immediately-on-a-microtask if it already was, or
-     * when the channel completes without one (SSR-errored queries are not
-     * dehydrated, so their components must not wait forever).
-     */
-    whenQueryPrimed: (queryHash: string, callback: () => void) => void;
-}
-
-export declare const HydrationCoordinatorContext: Context<HydrationCoordinator | null>;
+/**
+ * Namespace prefix for cache entries in Solid's hydration registry — the
+ * registry is shared with positional node ids and other libraries'
+ * content-addressed keys (Solid Router uses its own cache keys), so query
+ * hashes get their own prefix.
+ */
+export declare const HYDRATION_KEY_PREFIX = "sq:";
 
 export { InferDataFromTag }
 
@@ -379,15 +389,7 @@ export { InfiniteQueryObserverLoadingErrorResult }
 
 export { InfiniteQueryObserverLoadingResult }
 
-declare interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'structuralSharing'> {
-    /**
-     * Set this to a reconciliation key to enable reconciliation between query results.
-     * Set this to `false` to disable reconciliation between query results.
-     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
-     * Defaults reconciliation to false.
-     */
-    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
-}
+declare type InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, TQueryKey, TPageParam>;
 export { InfiniteQueryObserverOptions }
 export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }
 
@@ -404,18 +406,16 @@ export { InfiniteQueryObserverSuccessResult }
 declare interface InfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
     queryKey: TQueryKey;
     /**
-     * Only applicable while rendering queries on the server with streaming.
-     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
-     * This can be useful to avoid sending a loading state to the client before the query has resolved.
-     * Defaults to `false`.
+     * Defer the SSR stream flush until this query resolves on the server —
+     * see {@link UseBaseQueryOptions.deferStream}.
      */
     deferStream?: boolean;
     /**
-     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-     * The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
-     * Setting `suspense` to `false` will be a no-op.
+     * Reconciliation key for the data store — see
+     * {@link UseBaseQueryOptions.reconcile}. For infinite queries this keys
+     * items within pages; pages themselves merge positionally.
      */
-    suspense?: boolean;
+    reconcile?: string | ((item: NonNullable<any>) => any) | null;
 }
 export { InfiniteQueryOptions }
 export { InfiniteQueryOptions as InfiniteQueryOptions_alias_1 }
@@ -530,6 +530,12 @@ export { notifyManager }
 
 export { NotifyOnChangeProps }
 
+/**
+ * Distributes an `isInitialLoading` omit over result unions so status
+ * discriminants survive (a plain Omit over a union collapses it).
+ */
+declare type OmitIsInitialLoading<T> = T extends unknown ? OmitKeyof<T, 'isInitialLoading' & keyof T> : never;
+
 export { OmitKeyof }
 
 export { onlineManager }
@@ -598,6 +604,18 @@ declare const QueryClientContext: Context<(() => QueryClient) | null>;
 export { QueryClientContext }
 export { QueryClientContext as QueryClientContext_alias_1 }
 
+/**
+ * Provides the QueryClient and manages its mount lifecycle. On the server
+ * it also registers the cache serializer above; on the client, hooks prime
+ * the cache from their hash-keyed registry entries themselves (see
+ * `useBaseQuery`) and the provider subscribes the cache's single-flight
+ * consumer: mutation responses carrying a `FLIGHT_DATA_SOURCE` slice (a
+ * `DehydratedState` produced by a server collector registered under the
+ * same id) hydrate this client before the mutation's promise resolves.
+ * Subscribing is inert when no server collector exists — the server just
+ * folds nothing — so it is unconditional. One consumer per source: with
+ * nested providers, the innermost mounted one owns the slice.
+ */
 declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
 export { QueryClientProvider }
 export { QueryClientProvider as QueryClientProvider_alias_1 }
@@ -629,15 +647,14 @@ export { QueryObserverLoadingErrorResult }
 
 export { QueryObserverLoadingResult }
 
-declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions_2<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
-    /**
-     * Set this to a reconciliation key to enable reconciliation between query results.
-     * Set this to `false` to disable reconciliation between query results.
-     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
-     * Defaults reconciliation to false.
-     */
-    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
-}
+/**
+ * Core observer options pass through unchanged. The old adapter omitted
+ * `structuralSharing` and replaced it with a store-level `reconcile`
+ * option; with reads derived directly from cache state, core's
+ * cache-level structural sharing is exactly what keeps the data memo
+ * referentially stable, so it is exposed again and `reconcile` is gone.
+ */
+declare type QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = QueryObserverOptions_2<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>;
 export { QueryObserverOptions }
 export { QueryObserverOptions as QueryObserverOptions_alias_1 }
 
@@ -724,38 +741,49 @@ export { unsetMarker }
 
 export { Updater }
 
-declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
+declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<OmitKeyof<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, 'context'>, {
     mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
-}> & {
-    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
-};
-export { UseBaseMutationResult as CreateBaseMutationResult }
+}>;
 export { UseBaseMutationResult }
 export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }
 
-export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): Readonly<QueryObserverResult<TData, TError>>;
+export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): UseBaseQueryResult<TData, TError>;
+
+export declare function useBaseQueryLayer<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): BaseQueryLayer<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
 
 declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
     /**
-     * Only applicable while rendering queries on the server with streaming.
-     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
-     * This can be useful to avoid sending a loading state to the client before the query has resolved.
-     * Defaults to `false`.
+     * Defer the SSR stream flush until this query resolves on the server,
+     * instead of letting the surrounding `<Loading>` boundary render its
+     * fallback into the HTML. Passed through to Solid's own per-computation
+     * `deferStream` option; server-only, ignored on the client.
      */
     deferStream?: boolean;
     /**
-     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-     * The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
-     * Setting `suspense` to `false` will be a no-op.
+     * Reconciliation key for the data store. `data` is served as a Solid
+     * store projection: every landing (refetch, invalidation, placeholder
+     * upgrade) reconciles into the existing proxy graph instead of replacing
+     * it, so deep reads are fine-grained and item identity survives across
+     * fetches. This sets the identity key for that reconciliation — a
+     * property name, a key-extraction function, or `null` to merge
+     * positionally. Defaults to `'id'`. Read once at creation.
      */
-    suspense?: boolean;
+    reconcile?: string | ((item: NonNullable<any>) => any) | null;
 }
-export { UseBaseQueryOptions as CreateBaseQueryOptions }
 export { UseBaseQueryOptions }
 export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }
 
-declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
-export { UseBaseQueryResult as CreateBaseQueryResult }
+/**
+ * `data` is non-optional: it is a suspending async read. It never returns
+ * `undefined` — a read either suspends into the nearest `<Loading>`
+ * boundary (first fetch in flight, disabled, restoring), returns a value
+ * (committed, placeholder, initial), or throws (`<Errored>` /
+ * `throwOnError`). The v5 `TData | undefined` face existed because reads
+ * could observe the pre-fetch gap; here that gap is suspension.
+ */
+declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = Override<OmitKeyof<QueryObserverResult<TData, TError>, 'isInitialLoading'>, {
+    data: TData;
+}>;
 export { UseBaseQueryResult }
 export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }
 
@@ -766,22 +794,21 @@ export { useInfiniteQuery }
 export { useInfiniteQuery as useInfiniteQuery_alias_1 }
 
 declare type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<InfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
-export { UseInfiniteQueryOptions as CreateInfiniteQueryOptions }
 export { UseInfiniteQueryOptions }
 export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }
 
-declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
-export { UseInfiniteQueryResult as CreateInfiniteQueryResult }
+/** Non-optional `data` for the same reason as {@link UseBaseQueryResult}. */
+declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = Override<OmitKeyof<InfiniteQueryObserverResult<TData, TError>, 'isInitialLoading'>, {
+    data: TData;
+}>;
 export { UseInfiniteQueryResult }
 export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }
 
 declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-export { useIsFetching as createIsFetching }
 export { useIsFetching }
 export { useIsFetching as useIsFetching_alias_1 }
 
 declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-export { useIsMutating as createIsMutating }
 export { useIsMutating }
 export { useIsMutating as useIsMutating_alias_1 }
 
@@ -789,36 +816,62 @@ declare const useIsRestoring: () => Accessor<boolean>;
 export { useIsRestoring }
 export { useIsRestoring as useIsRestoring_alias_1 }
 
-declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
-export { UseMutateAsyncFunction as CreateMutateAsyncFunction }
-export { UseMutateAsyncFunction }
-export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }
-
-declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
-export { UseMutateFunction as CreateMutateFunction }
+/**
+ * One `mutate`, returning a safe-to-ignore promise: errors are also routed
+ * into reactive state, and ignoring the promise never surfaces an
+ * unhandled rejection. Call-site callbacks are gone — settle logic that
+ * used to live in `mutate(vars, { onSuccess })` is linear code after
+ * `await mutate(vars)` or a config-level callback.
+ */
+declare type UseMutateFunction<TData = unknown, _TError = DefaultError, TVariables = void, _TOnMutateResult = unknown> = (variables: TVariables) => Promise<TData>;
 export { UseMutateFunction }
 export { UseMutateFunction as UseMutateFunction_alias_1 }
 
+/**
+ * Mutations ride core `action`: each `mutate()` call is one transaction.
+ *
+ * - Transient flight state (`isPending`, in-flight `variables`) is a
+ *   `createOptimistic` overlay written at the top of the action — visible
+ *   immediately, dropped automatically when the transition settles. The
+ *   engine's revert-on-settle IS the submission state machine.
+ * - `options.onMutate(variables)` runs inside the same window: it is the
+ *   place to apply the caller's own optimistic overlays
+ *   (`createOptimistic` / `createOptimisticStore` writes). No context
+ *   object, no rollback plumbing — reverting is the engine's job.
+ * - The fetch itself goes through query-core:
+ *   `mutationCache.build().execute()` supplies retry/backoff, offline
+ *   pausing, scoped serial execution, and cache-level lifecycle callbacks.
+ *   No `MutationObserver` — the adapter reads the Mutation's state
+ *   directly where flight metadata (failureCount, isPaused) is needed.
+ * - Options-level callbacks are stripped from the built mutation and
+ *   re-run *post-`yield`*, inside the transaction: an
+ *   `onSuccess → invalidateQueries` chain issues version bumps whose
+ *   refetches hold this very transition, so mutation success and fresh
+ *   query data land in one atomic paint (and a single-flight payload has
+ *   already primed the cache by the time `execute` resolves).
+ * - One `mutate`, returning a safe-to-ignore promise: rejection is also
+ *   routed into reactive state, and a no-op catch keeps the ignored
+ *   branch from surfacing as an unhandled rejection. The
+ *   `mutate`/`mutateAsync` split existed for React's callback-vs-promise
+ *   error routing; it has no space here.
+ */
 declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
 export { useMutation }
 export { useMutation as useMutation_alias_1 }
 
 declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<MutationOptions<TData, TError, TVariables, TOnMutateResult>>;
-export { UseMutationOptions as CreateMutationOptions }
 export { UseMutationOptions }
 export { UseMutationOptions as UseMutationOptions_alias_1 }
 
 declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
-export { UseMutationResult as CreateMutationResult }
 export { UseMutationResult }
 export { UseMutationResult as UseMutationResult_alias_1 }
 
 declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
-export { useMutationState as createMutationState }
 export { useMutationState }
 export { useMutationState as useMutationState_alias_1 }
 
-declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
+declare function useQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>(queriesOptions: Accessor<{
     queries: readonly [...QueriesOptions<T>] | readonly [...{
         [K in keyof T]: GetOptions<T[K]>;
     }];
@@ -838,23 +891,21 @@ export { useQueryClient }
 export { useQueryClient as useQueryClient_alias_1 }
 
 declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<QueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
-export { UseQueryOptions as CreateQueryOptions }
 export { UseQueryOptions }
 export { UseQueryOptions as UseQueryOptions_alias_1 }
 
-declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
+declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<QueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
     placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
     /**
-     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-     * The `data` property on useQueries is a plain object and not a SolidJS Resource.
-     * It will not suspend when the data is loading.
-     * Setting `suspense` to `true` will be a no-op.
+     * @deprecated The `suspense` option has been removed. Suspense is the
+     * model: each result's `data` is an async read that suspends into the
+     * nearest `<Loading>` boundary while its first fetch is in flight, same
+     * as `useQuery`. Setting `suspense` is a no-op.
      */
     suspense?: boolean;
 };
 
 declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
-export { UseQueryResult as CreateQueryResult }
 export { UseQueryResult }
 export { UseQueryResult as UseQueryResult_alias_1 }