) {
+ return useQueries({
+ queries: ids.map((id) => ({
+ queryKey: ['user', id],
+ queryFn: async () => ({ id }),
+ })),
+ })
+}
+```
+
+Duplicate keys can share placeholder, selected, or cached data between different items.
+
+Source: TanStack/query:docs/framework/react/reference/useQueries.md
+
+### MEDIUM Full-page spinner on background refetch
+
+Wrong:
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const query = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return query.isFetching ? (
+ Loading
+ ) : (
+ {JSON.stringify(query.data)}
+ )
+}
+```
+
+Correct:
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const query = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return (
+
+ {query.isFetching ? 'Refreshing ' : ''}
+ {JSON.stringify(query.data ?? [])}
+
+ )
+}
+```
+
+`isFetching` also covers background refreshes after data is already available.
+
+Source: TanStack/query:docs/framework/react/guides/background-fetching-indicators.md
diff --git a/packages/query-intent/skills/core/design-query-keys-and-options/SKILL.md b/packages/query-intent/skills/core/design-query-keys-and-options/SKILL.md
new file mode 100644
index 00000000000..36b6dd98a54
--- /dev/null
+++ b/packages/query-intent/skills/core/design-query-keys-and-options/SKILL.md
@@ -0,0 +1,182 @@
+---
+name: core/design-query-keys-and-options
+description: >
+ Use this when designing queryKey arrays, queryFn inputs, queryOptions,
+ infiniteQueryOptions, mutationOptions, skipToken, key factories, or TypeScript
+ inference for TanStack Query reads and writes.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+sources:
+ - TanStack/query:docs/framework/react/guides/query-keys.md
+ - TanStack/query:docs/framework/react/guides/query-options.md
+ - TanStack/query:docs/framework/react/typescript.md
+ - TanStack/query:docs/eslint/exhaustive-deps.md
+ - TanStack/query:docs/eslint/prefer-query-options.md
+---
+
+## Setup
+
+```ts
+import { queryOptions } from '@tanstack/react-query'
+
+export function todoOptions(todoId: string) {
+ return queryOptions({
+ queryKey: ['todo', todoId],
+ queryFn: async () => ({ id: todoId, title: 'Ship skills' }),
+ staleTime: 60_000,
+ })
+}
+```
+
+## Core Patterns
+
+### Put every query variable in the key
+
+```ts
+import { queryOptions } from '@tanstack/react-query'
+
+export function projectsOptions(teamId: string, page: number) {
+ return queryOptions({
+ queryKey: ['projects', teamId, page],
+ queryFn: async () => ({ teamId, page, items: [] as Array<{ id: string }> }),
+ })
+}
+```
+
+### Share one options factory
+
+```ts
+import { QueryClient, useQuery, queryOptions } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+
+export function userOptions(userId: string) {
+ return queryOptions({
+ queryKey: ['user', userId],
+ queryFn: async () => ({ id: userId, name: 'Tanner' }),
+ })
+}
+
+export function useUser(userId: string) {
+ return useQuery(userOptions(userId))
+}
+
+export function preloadUser(userId: string) {
+ return queryClient.ensureQueryData(userOptions(userId))
+}
+```
+
+### Use skipToken for typesafe absence
+
+```ts
+import { skipToken, useQuery } from '@tanstack/react-query'
+
+export function useMaybeTodo(todoId: string | undefined) {
+ return useQuery({
+ queryKey: ['todo', todoId],
+ queryFn: todoId ? async () => ({ id: todoId }) : skipToken,
+ })
+}
+```
+
+## Common Mistakes
+
+### CRITICAL Missing variable in key
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useProject(teamId: string) {
+ return useQuery({
+ queryKey: ['project'],
+ queryFn: async () => ({ teamId }),
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useProject(teamId: string) {
+ return useQuery({
+ queryKey: ['project', teamId],
+ queryFn: async () => ({ teamId }),
+ })
+}
+```
+
+Query keys define cache identity; missing variables merge distinct data.
+
+Source: TanStack/query:docs/framework/react/guides/query-keys.md
+
+### HIGH Key and queryFn drift
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodo(todoId: string) {
+ return useQuery({ queryKey: ['todo'], queryFn: async () => ({ id: todoId }) })
+}
+```
+
+Correct:
+
+```ts
+import { queryOptions, useQuery } from '@tanstack/react-query'
+
+function todoOptions(todoId: string) {
+ return queryOptions({
+ queryKey: ['todo', todoId],
+ queryFn: async () => ({ id: todoId }),
+ })
+}
+
+export function useTodo(todoId: string) {
+ return useQuery(todoOptions(todoId))
+}
+```
+
+Options factories keep identity, fetch behavior, and inference together across hooks and prefetches.
+
+Source: TanStack/query:docs/eslint/prefer-query-options.md
+
+### HIGH skipToken inside suspense query
+
+Wrong:
+
+```ts
+import { skipToken, useSuspenseQuery } from '@tanstack/react-query'
+
+export function useTodo(todoId: string | undefined) {
+ return useSuspenseQuery({
+ queryKey: ['todo', todoId],
+ queryFn: todoId ? async () => ({ id: todoId }) : skipToken,
+ })
+}
+```
+
+Correct:
+
+```ts
+import { skipToken, useQuery } from '@tanstack/react-query'
+
+export function useTodo(todoId: string | undefined) {
+ return useQuery({
+ queryKey: ['todo', todoId],
+ queryFn: todoId ? async () => ({ id: todoId }) : skipToken,
+ })
+}
+```
+
+Suspense queries require a guaranteed query function and cannot be conditionally disabled.
+
+Source: TanStack/query:docs/framework/react/guides/suspense.md
+
+See also: `compositions/enforce-query-best-practices-with-eslint` for rules that enforce key and options mistakes.
diff --git a/packages/query-intent/skills/core/fetch-and-observe-queries/SKILL.md b/packages/query-intent/skills/core/fetch-and-observe-queries/SKILL.md
new file mode 100644
index 00000000000..f5eac95fa46
--- /dev/null
+++ b/packages/query-intent/skills/core/fetch-and-observe-queries/SKILL.md
@@ -0,0 +1,195 @@
+---
+name: core/fetch-and-observe-queries
+description: >
+ Use this when reading server state with useQuery, useQueries, createQuery,
+ injectQuery, QueryObserver, QueryClient.fetchQuery, ensureQueryData, status,
+ fetchStatus, pending, paused, success, and error states.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - lifecycle/setup-query-client-and-providers
+ - core/design-query-keys-and-options
+sources:
+ - TanStack/query:docs/framework/react/guides/queries.md
+ - TanStack/query:docs/framework/react/guides/query-functions.md
+ - TanStack/query:docs/reference/QueryObserver.md
+ - TanStack/query:docs/reference/QueryClient.md
+ - TanStack/query:docs/eslint/no-void-query-fn.md
+---
+
+## Setup
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const query = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1, title: 'Ship' }],
+ })
+
+ if (query.isPending) return Loading
+ if (query.isError) return {query.error.message}
+ return {JSON.stringify(query.data)}
+}
+```
+
+## Core Patterns
+
+### Fetch imperatively through QueryClient
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+export function loadTodo(todoId: string) {
+ return queryClient.fetchQuery({
+ queryKey: ['todo', todoId],
+ queryFn: async () => ({ id: todoId }),
+ })
+}
+```
+
+### Ensure cached data for loaders
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+export function ensureTodos() {
+ return queryClient.ensureQueryData({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+}
+```
+
+### Distinguish status from fetchStatus
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function TodoCount() {
+ const query = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ const label =
+ query.fetchStatus === 'fetching' && query.status === 'success'
+ ? 'Refreshing'
+ : 'Ready'
+ return (
+
+ {query.data?.length ?? 0} {label}
+
+ )
+}
+```
+
+## Common Mistakes
+
+### CRITICAL Void query function
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => {
+ await Promise.resolve([{ id: 1 }])
+ },
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => Promise.resolve([{ id: 1 }]),
+ })
+}
+```
+
+Query functions must return data; a missing return caches `undefined`.
+
+Source: TanStack/query:docs/eslint/no-void-query-fn.md
+
+### HIGH Only checking pending offline
+
+Wrong:
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const query = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ networkMode: 'online',
+ })
+ return query.isPending ? Loading
: {query.fetchStatus}
+}
+```
+
+Correct:
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const query = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ networkMode: 'online',
+ })
+ return query.fetchStatus === 'paused' ? Offline
: {query.status}
+}
+```
+
+`status` describes data state; `fetchStatus` describes whether fetching is paused, fetching, or idle.
+
+Source: TanStack/query:docs/framework/react/guides/queries.md
+
+### HIGH Using queries for writes
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useSaveTodo(title: string) {
+ return useQuery({
+ queryKey: ['saveTodo', title],
+ queryFn: async () => ({ id: 1, title }),
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useMutation } from '@tanstack/react-query'
+
+export function useSaveTodo() {
+ return useMutation({
+ mutationFn: async (title: string) => ({ id: 1, title }),
+ })
+}
+```
+
+Queries are for reads; writes need mutation lifecycle hooks, invalidation, rollback, and mutation state.
+
+Source: TanStack/query:docs/framework/react/guides/mutations.md
+
+See also: `core/tune-defaults-freshness-retries-and-refetching` for how defaults change status behavior.
diff --git a/packages/query-intent/skills/core/implement-optimistic-updates-and-cache-writes/SKILL.md b/packages/query-intent/skills/core/implement-optimistic-updates-and-cache-writes/SKILL.md
new file mode 100644
index 00000000000..6a13f22ace6
--- /dev/null
+++ b/packages/query-intent/skills/core/implement-optimistic-updates-and-cache-writes/SKILL.md
@@ -0,0 +1,178 @@
+---
+name: core/implement-optimistic-updates-and-cache-writes
+description: >
+ Use this when implementing optimistic updates, onMutate rollback context,
+ cancelQueries before writes, setQueryData, setQueriesData, immutable cache writes,
+ mutation rollback, and offline-aware optimistic state.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/write-mutations-and-invalidate-related-queries
+ - core/cancel-queries-and-consume-abort-signals
+sources:
+ - TanStack/query:docs/framework/react/guides/optimistic-updates.md
+ - TanStack/query:docs/framework/react/guides/updates-from-mutation-responses.md
+ - TanStack/query:docs/framework/react/guides/query-cancellation.md
+ - TanStack/query:docs/framework/react/plugins/persistQueryClient.md
+---
+
+## Setup
+
+```ts
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+type Todo = { id: number; title: string }
+
+export function useOptimisticAddTodo() {
+ const queryClient = useQueryClient()
+ return useMutation({
+ mutationFn: async (title: string) => ({ id: Date.now(), title }),
+ onMutate: async (title) => {
+ await queryClient.cancelQueries({ queryKey: ['todos'] })
+ const previous = queryClient.getQueryData>(['todos'])
+ queryClient.setQueryData>(['todos'], (old = []) => [
+ ...old,
+ { id: -1, title },
+ ])
+ return { previous }
+ },
+ onError: (_error, _title, context) => {
+ queryClient.setQueryData(['todos'], context?.previous)
+ },
+ onSettled: async () => {
+ await queryClient.invalidateQueries({ queryKey: ['todos'] })
+ },
+ })
+}
+```
+
+## Core Patterns
+
+### Write mutation response into detail cache
+
+```ts
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+export function useUpdateTodo() {
+ const queryClient = useQueryClient()
+ return useMutation({
+ mutationFn: async (todo: { id: number; title: string }) => todo,
+ onSuccess: (todo) => queryClient.setQueryData(['todo', todo.id], todo),
+ })
+}
+```
+
+### Update lists immutably
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+queryClient.setQueryData>(
+ ['todos'],
+ (old = []) =>
+ old.map((todo) => (todo.id === 1 ? { ...todo, title: 'Done' } : todo)),
+)
+```
+
+### Roll back with context
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+const previous = queryClient.getQueryData(['todos'])
+queryClient.setQueryData(['todos'], [{ id: 1, title: 'Optimistic' }])
+queryClient.setQueryData(['todos'], previous)
+```
+
+## Common Mistakes
+
+### CRITICAL Optimistic write without cancellation
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+queryClient.setQueryData(['todos'], [{ id: 1, title: 'Optimistic' }])
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+await queryClient.cancelQueries({ queryKey: ['todos'] })
+queryClient.setQueryData(['todos'], [{ id: 1, title: 'Optimistic' }])
+```
+
+An in-flight refetch can overwrite an optimistic write unless it is cancelled first.
+
+Source: TanStack/query:docs/framework/react/guides/optimistic-updates.md
+
+### CRITICAL In-place mutation
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+queryClient.setQueryData>(
+ ['todos'],
+ (old = []) => {
+ old[0].done = true
+ return old
+ },
+)
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+queryClient.setQueryData>(
+ ['todos'],
+ (old = []) =>
+ old.map((todo) => (todo.id === 1 ? { ...todo, done: true } : todo)),
+)
+```
+
+Cache updates must be immutable so observers can detect and share changes correctly.
+
+Source: TanStack/query:docs/framework/react/guides/updates-from-mutation-responses.md
+
+### HIGH Persisted persister loses optimistic mutation
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+queryClient.setMutationDefaults(['updateTodo'], {})
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+queryClient.setMutationDefaults(['updateTodo'], {
+ mutationFn: async (todo: { id: number; title: string }) => todo,
+})
+```
+
+Paused persisted mutations need a default mutationFn after hydration because functions cannot be serialized.
+
+Source: TanStack/query:docs/framework/react/plugins/persistQueryClient.md
+
+See also: `core/cancel-queries-and-consume-abort-signals` before optimistic writes.
diff --git a/packages/query-intent/skills/core/paginate-and-build-infinite-queries/SKILL.md b/packages/query-intent/skills/core/paginate-and-build-infinite-queries/SKILL.md
new file mode 100644
index 00000000000..51c5bbcb4bc
--- /dev/null
+++ b/packages/query-intent/skills/core/paginate-and-build-infinite-queries/SKILL.md
@@ -0,0 +1,191 @@
+---
+name: core/paginate-and-build-infinite-queries
+description: >
+ Use this when implementing pagination, lagged queries, placeholderData,
+ keepPreviousData migration, useInfiniteQuery, initialPageParam,
+ getNextPageParam, getPreviousPageParam, maxPages, pages, or pageParams.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/design-query-keys-and-options
+ - core/fetch-and-observe-queries
+sources:
+ - TanStack/query:docs/framework/react/guides/paginated-queries.md
+ - TanStack/query:docs/framework/react/guides/infinite-queries.md
+ - TanStack/query:docs/framework/react/reference/useInfiniteQuery.md
+ - TanStack/query:docs/reference/InfiniteQueryObserver.md
+ - TanStack/query:docs/eslint/infinite-query-property-order.md
+---
+
+## Setup
+
+```ts
+import { keepPreviousData, useQuery } from '@tanstack/react-query'
+
+export function useProjects(page: number) {
+ return useQuery({
+ queryKey: ['projects', page],
+ queryFn: async () => ({ page, projects: [{ id: page }] }),
+ placeholderData: keepPreviousData,
+ })
+}
+```
+
+## Core Patterns
+
+### Build an infinite query
+
+```ts
+import { useInfiniteQuery } from '@tanstack/react-query'
+
+export function useFeed() {
+ return useInfiniteQuery({
+ queryKey: ['feed'],
+ queryFn: async ({ pageParam }) => ({
+ nextCursor: pageParam + 1,
+ items: [{ id: pageParam }],
+ }),
+ initialPageParam: 0,
+ getNextPageParam: (lastPage) => lastPage.nextCursor,
+ })
+}
+```
+
+### Bound memory with maxPages
+
+```ts
+import { useInfiniteQuery } from '@tanstack/react-query'
+
+export function useBoundedFeed() {
+ return useInfiniteQuery({
+ queryKey: ['feed'],
+ queryFn: async ({ pageParam }) => ({
+ nextCursor: pageParam + 1,
+ items: [{ id: pageParam }],
+ }),
+ initialPageParam: 0,
+ getNextPageParam: (lastPage) => lastPage.nextCursor,
+ maxPages: 5,
+ })
+}
+```
+
+### Preserve infinite data shape
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+queryClient.setQueryData(['feed'], {
+ pages: [{ items: [{ id: 1 }], nextCursor: 2 }],
+ pageParams: [1],
+})
+```
+
+## Common Mistakes
+
+### CRITICAL Missing initialPageParam
+
+Wrong:
+
+```ts
+import { useInfiniteQuery } from '@tanstack/react-query'
+
+export function useFeed() {
+ return useInfiniteQuery({
+ queryKey: ['feed'],
+ queryFn: async () => ({ items: [] }),
+ getNextPageParam: () => 1,
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useInfiniteQuery } from '@tanstack/react-query'
+
+export function useFeed() {
+ return useInfiniteQuery({
+ queryKey: ['feed'],
+ queryFn: async ({ pageParam }) => ({ items: [pageParam] }),
+ initialPageParam: 0,
+ getNextPageParam: () => 1,
+ })
+}
+```
+
+v5 requires an explicit initial page param so pageParams can be serialized and inferred.
+
+Source: TanStack/query:docs/framework/react/guides/infinite-queries.md
+
+### HIGH Overlapping infinite fetches
+
+Wrong:
+
+```tsx
+import { useInfiniteQuery } from '@tanstack/react-query'
+
+export function Feed() {
+ const query = useInfiniteQuery({
+ queryKey: ['feed'],
+ queryFn: async ({ pageParam }) => ({ nextCursor: pageParam + 1 }),
+ initialPageParam: 0,
+ getNextPageParam: (page) => page.nextCursor,
+ })
+ return
+}
+```
+
+Correct:
+
+```tsx
+import { useInfiniteQuery } from '@tanstack/react-query'
+
+export function Feed() {
+ const query = useInfiniteQuery({
+ queryKey: ['feed'],
+ queryFn: async ({ pageParam }) => ({ nextCursor: pageParam + 1 }),
+ initialPageParam: 0,
+ getNextPageParam: (page) => page.nextCursor,
+ })
+ return (
+
+ )
+}
+```
+
+Only one ongoing fetch should update an infinite query cache at a time unless explicitly overridden.
+
+Source: TanStack/query:docs/framework/react/guides/infinite-queries.md
+
+### HIGH Broken pages shape
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+queryClient.setQueryData(['feed'], [{ id: 1 }])
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+queryClient.setQueryData(['feed'], { pages: [[{ id: 1 }]], pageParams: [0] })
+```
+
+Infinite query data must keep `pages` and `pageParams`; refetches expect that shape.
+
+Source: TanStack/query:docs/framework/react/guides/infinite-queries.md
diff --git a/packages/query-intent/skills/core/seed-placeholder-select-and-transform-data/SKILL.md b/packages/query-intent/skills/core/seed-placeholder-select-and-transform-data/SKILL.md
new file mode 100644
index 00000000000..ba80cd170c5
--- /dev/null
+++ b/packages/query-intent/skills/core/seed-placeholder-select-and-transform-data/SKILL.md
@@ -0,0 +1,188 @@
+---
+name: core/seed-placeholder-select-and-transform-data
+description: >
+ Use this when choosing initialData, initialDataUpdatedAt, placeholderData,
+ keepPreviousData, select, data transformation, cache seeding, detail-from-list
+ seeding, or derived query data.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/design-query-keys-and-options
+ - core/fetch-and-observe-queries
+sources:
+ - TanStack/query:docs/framework/react/guides/initial-query-data.md
+ - TanStack/query:docs/framework/react/guides/placeholder-query-data.md
+ - TanStack/query:docs/framework/react/guides/render-optimizations.md
+ - TanStack/query:docs/framework/react/reference/queryOptions.md
+---
+
+## Setup
+
+```ts
+import { keepPreviousData, useQuery } from '@tanstack/react-query'
+
+export function useProjects(page: number) {
+ return useQuery({
+ queryKey: ['projects', page],
+ queryFn: async () => ({ page, items: [{ id: page }] }),
+ placeholderData: keepPreviousData,
+ })
+}
+```
+
+## Core Patterns
+
+### Seed detail data from a list
+
+```ts
+import { QueryClient, useQuery } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+export function useTodo(todoId: number) {
+ return useQuery({
+ queryKey: ['todo', todoId],
+ queryFn: async () => ({ id: todoId, title: 'Fresh' }),
+ initialData: () =>
+ queryClient
+ .getQueryData>(['todos'])
+ ?.find((todo) => todo.id === todoId),
+ })
+}
+```
+
+### Select the smallest shape
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodoCount() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }, { id: 2 }],
+ select: (todos) => todos.length,
+ })
+}
+```
+
+### Transform in the query function for cache-wide shape
+
+```ts
+import { queryOptions } from '@tanstack/react-query'
+
+export const todosOptions = queryOptions({
+ queryKey: ['todos'],
+ queryFn: async () =>
+ [{ id: 1, title: 'ship' }].map((todo) => ({
+ ...todo,
+ title: todo.title.toUpperCase(),
+ })),
+})
+```
+
+## Common Mistakes
+
+### HIGH initialData overwrite assumption
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodo() {
+ return useQuery({
+ queryKey: ['todo', 1],
+ queryFn: async () => ({ id: 1, title: 'Server' }),
+ initialData: { id: 1, title: 'Always' },
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodo() {
+ return useQuery({
+ queryKey: ['todo', 1],
+ queryFn: async () => ({ id: 1, title: 'Server' }),
+ placeholderData: { id: 1, title: 'Temporary' },
+ })
+}
+```
+
+`initialData` is persisted to cache as real data; placeholder data is observer-local.
+
+Source: TanStack/query:docs/framework/react/guides/initial-query-data.md
+
+### HIGH v4 keepPreviousData option
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function usePage(page: number) {
+ return useQuery({
+ queryKey: ['page', page],
+ queryFn: async () => ({ page }),
+ keepPreviousData: true,
+ })
+}
+```
+
+Correct:
+
+```ts
+import { keepPreviousData, useQuery } from '@tanstack/react-query'
+
+export function usePage(page: number) {
+ return useQuery({
+ queryKey: ['page', page],
+ queryFn: async () => ({ page }),
+ placeholderData: keepPreviousData,
+ })
+}
+```
+
+v5 replaced the `keepPreviousData` option with `placeholderData: keepPreviousData`.
+
+Source: TanStack/query:docs/framework/react/guides/migrating-to-v5.md
+
+### MEDIUM Throwing in select
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useFirstTodo() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [] as Array<{ id: number }>,
+ select: (todos) => todos[0].id,
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useFirstTodo() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [] as Array<{ id: number }>,
+ select: (todos) => todos[0]?.id ?? null,
+ })
+}
+```
+
+`select` transforms successful data; it is not the right place to model fetch errors.
+
+Source: TanStack/query:docs/framework/react/guides/render-optimizations.md
+
+See also: `lifecycle/ssr-hydration-and-streaming` for SSR tradeoffs compared to hydration.
diff --git a/packages/query-intent/skills/core/selectors-and-derived-state/SKILL.md b/packages/query-intent/skills/core/selectors-and-derived-state/SKILL.md
new file mode 100644
index 00000000000..ee12eca73d1
--- /dev/null
+++ b/packages/query-intent/skills/core/selectors-and-derived-state/SKILL.md
@@ -0,0 +1,153 @@
+---
+name: core/selectors-and-derived-state
+description: >
+ Use this when selecting, transforming, or deriving data from TanStack Query:
+ select functions, selector memoization, fine-grained subscriptions, structural
+ sharing, queryOptions composition with select, and deriving client state from
+ server state instead of syncing it through effects.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/seed-placeholder-select-and-transform-data
+ - framework/shape-data-and-render-efficiently
+sources:
+ - https://tkdodo.eu/blog/react-query-selectors-supercharged
+ - https://tkdodo.eu/blog/deriving-client-state-from-server-state
+ - TanStack/query:docs/framework/react/guides/render-optimizations.md
+ - TanStack/query:docs/framework/react/reference/queryOptions.md
+---
+
+## Core Patterns
+
+Use `select` to subscribe a component to the data shape it actually needs while keeping the full response in the cache.
+
+### Select a stable slice
+
+```tsx
+import { queryOptions, useSuspenseQuery } from '@tanstack/react-query'
+
+const productOptions = (id: string) =>
+ queryOptions({
+ queryKey: ['product', id],
+ queryFn: () => fetchProduct(id),
+ })
+
+function ProductTitle({ id }: { id: string }) {
+ const title = useSuspenseQuery({
+ ...productOptions(id),
+ select: (product) => product.title,
+ })
+
+ return {title.data}
+}
+```
+
+### Stabilize expensive selectors
+
+```tsx
+const selectAverageRating = (products: Array) =>
+ expensiveAverage(products)
+
+function ProductSummary({ filters }: { filters: ProductFilters }) {
+ return useSuspenseQuery({
+ ...productsOptions(filters),
+ select: selectAverageRating,
+ })
+}
+```
+
+Use `React.useCallback` when the selector closes over component props. Move it outside the component when it has no dependencies.
+
+### Derive client state instead of syncing it
+
+```tsx
+const selectedUser = usersQuery.data?.find((user) => user.id === selectedUserId)
+const visibleSelectedUserId = selectedUser ? selectedUserId : null
+```
+
+When server data changes, derived values update naturally during render.
+
+## Common Mistakes
+
+### HIGH Syncing derived state through an effect
+
+Wrong:
+
+```tsx
+React.useEffect(() => {
+ if (!users?.some((user) => user.id === selectedUserId)) {
+ setSelectedUserId(null)
+ }
+}, [users, selectedUserId])
+```
+
+Correct:
+
+```tsx
+const selectedUser = users?.find((user) => user.id === selectedUserId)
+const visibleSelectedUserId = selectedUser ? selectedUserId : null
+```
+
+Prefer deriving client state from server state during render when no side effect is required.
+
+Source: https://tkdodo.eu/blog/deriving-client-state-from-server-state
+
+### MEDIUM Inline expensive select reruns on unrelated renders
+
+Wrong:
+
+```tsx
+useSuspenseQuery({
+ ...productsOptions(filters),
+ select: (data) => expensiveSuperTransformation(data),
+})
+```
+
+Correct:
+
+```tsx
+const selectProducts = (data: Array) =>
+ expensiveSuperTransformation(data)
+
+useSuspenseQuery({
+ ...productsOptions(filters),
+ select: selectProducts,
+})
+```
+
+TanStack Query reruns `select` when data changes or the selector function identity changes.
+
+Source: https://tkdodo.eu/blog/react-query-selectors-supercharged
+
+### MEDIUM Using select to throw domain errors
+
+Wrong:
+
+```tsx
+useQuery({
+ queryKey: ['todos'],
+ queryFn: fetchTodos,
+ select: (todos) => {
+ if (!todos.length) throw new Error('No todos')
+ return todos
+ },
+})
+```
+
+Correct:
+
+```tsx
+useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => {
+ const todos = await fetchTodos()
+ if (!todos.length) throw new Error('No todos')
+ return todos
+ },
+})
+```
+
+`select` transforms successful data. Query errors belong in the query function.
+
+Source: TanStack/query:docs/framework/react/guides/render-optimizations.md
diff --git a/packages/query-intent/skills/core/tune-defaults-freshness-retries-and-refetching/SKILL.md b/packages/query-intent/skills/core/tune-defaults-freshness-retries-and-refetching/SKILL.md
new file mode 100644
index 00000000000..b100963d205
--- /dev/null
+++ b/packages/query-intent/skills/core/tune-defaults-freshness-retries-and-refetching/SKILL.md
@@ -0,0 +1,172 @@
+---
+name: core/tune-defaults-freshness-retries-and-refetching
+description: >
+ Use this when configuring staleTime, gcTime, cache lifetime, retry, retryDelay,
+ refetchOnWindowFocus, refetchOnReconnect, refetchInterval, networkMode,
+ focusManager, onlineManager, timeoutManager, or QueryClient defaultOptions.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/fetch-and-observe-queries
+sources:
+ - TanStack/query:docs/framework/react/guides/important-defaults.md
+ - TanStack/query:docs/framework/react/guides/caching.md
+ - TanStack/query:docs/framework/react/guides/query-retries.md
+ - TanStack/query:docs/framework/react/guides/window-focus-refetching.md
+ - TanStack/query:docs/framework/react/guides/network-mode.md
+ - TanStack/query:docs/reference/focusManager.md
+ - TanStack/query:docs/reference/onlineManager.md
+ - TanStack/query:docs/reference/timeoutManager.md
+---
+
+## Setup
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: {
+ queries: {
+ staleTime: 60_000,
+ gcTime: 10 * 60_000,
+ retry: 2,
+ refetchOnWindowFocus: true,
+ },
+ },
+})
+```
+
+## Core Patterns
+
+### Set freshness close to the data source
+
+```ts
+import { queryOptions } from '@tanstack/react-query'
+
+export const settingsOptions = queryOptions({
+ queryKey: ['settings'],
+ queryFn: async () => ({ theme: 'system' }),
+ staleTime: 5 * 60_000,
+})
+```
+
+### Disable retries in tests
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export function createTestQueryClient() {
+ return new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ })
+}
+```
+
+### Use networkMode deliberately
+
+```ts
+import { queryOptions } from '@tanstack/react-query'
+
+export const metricsOptions = queryOptions({
+ queryKey: ['metrics'],
+ queryFn: async () => ({ count: 1 }),
+ networkMode: 'online',
+})
+```
+
+## Common Mistakes
+
+### HIGH Confusing gcTime with freshness
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useProfile() {
+ return useQuery({
+ queryKey: ['profile'],
+ queryFn: async () => ({ name: 'Tanner' }),
+ gcTime: 60_000,
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useProfile() {
+ return useQuery({
+ queryKey: ['profile'],
+ queryFn: async () => ({ name: 'Tanner' }),
+ staleTime: 60_000,
+ })
+}
+```
+
+`gcTime` controls unused cache retention; `staleTime` controls whether cached data is considered fresh.
+
+Source: TanStack/query:docs/framework/react/guides/important-defaults.md
+
+### HIGH static staleTime blocks invalidation expectations
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ staleTime: 'static',
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ staleTime: 60_000,
+ })
+}
+```
+
+`staleTime: 'static'` opts out of refetching even when the query is invalidated.
+
+Source: TanStack/query:docs/framework/react/guides/important-defaults.md
+
+### HIGH Tests hang on retries
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+})
+```
+
+Default retries add delay and can make failing tests wait before surfacing errors.
+
+Source: TanStack/query:docs/framework/react/guides/testing.md
+
+See also: `compositions/persist-offline-and-restore-caches` for persistence rules that depend on gcTime and networkMode.
diff --git a/packages/query-intent/skills/core/understand-query-internals-and-observers/SKILL.md b/packages/query-intent/skills/core/understand-query-internals-and-observers/SKILL.md
new file mode 100644
index 00000000000..0b9ebd6132c
--- /dev/null
+++ b/packages/query-intent/skills/core/understand-query-internals-and-observers/SKILL.md
@@ -0,0 +1,114 @@
+---
+name: core/understand-query-internals-and-observers
+description: >
+ Use this when explaining or debugging TanStack Query internals: QueryClient,
+ QueryCache, MutationCache, Query, QueryObserver, active versus inactive
+ queries, observer-level options, subscriptions, stale timers, and why loaders
+ or imperative cache reads are not the same as observed queries.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/fetch-and-observe-queries
+sources:
+ - https://tkdodo.eu/blog/inside-react-query
+ - https://tkdodo.eu/blog/react-query-selectors-supercharged
+ - TanStack/query:docs/reference/QueryClient.md
+ - TanStack/query:docs/reference/QueryCache.md
+ - TanStack/query:docs/reference/QueryObserver.md
+ - TanStack/query:docs/reference/MutationCache.md
+---
+
+## Mental Model
+
+`QueryClient` owns the caches. `QueryCache` stores `Query` instances. Hooks and adapter APIs create `QueryObserver` instances that subscribe components to one query. Observer-level options like `select`, `staleTime`, polling, and tracked result access shape what each component sees.
+
+An inactive query can exist in the cache without active observers. It can be read imperatively, hydrated, invalidated, or garbage collected, but it is not the same as a component actively observing query state.
+
+## Core Patterns
+
+### Use observers for UI reads
+
+```tsx
+function TodoPage({ id }: { id: string }) {
+ const todo = useQuery({
+ queryKey: ['todo', id],
+ queryFn: () => fetchTodo(id),
+ })
+
+ if (todo.isPending) return Loading...
+ if (todo.isError) return {todo.error.message}
+ return {todo.data.title}
+}
+```
+
+### Use QueryClient for cache orchestration
+
+```ts
+await queryClient.ensureQueryData(todoOptions(id))
+queryClient.invalidateQueries({ queryKey: ['todo', id] })
+queryClient.setQueryData(['todo', id], (old) => old && { ...old, title })
+```
+
+## Common Mistakes
+
+### HIGH Treating cache presence as active usage
+
+Wrong:
+
+```tsx
+const todo = queryClient.getQueryData(['todo', id])
+return
+```
+
+Correct:
+
+```tsx
+const todo = useQuery(todoOptions(id))
+return
+```
+
+UI reads should create observers so invalidation, refetch triggers, stale status, and garbage collection behave as expected.
+
+Source: https://tkdodo.eu/blog/inside-react-query
+
+### MEDIUM Expecting one query to have one option set
+
+Wrong:
+
+```ts
+// assume staleTime is stored only on the Query
+queryClient.getQueryCache().find({ queryKey })?.options.staleTime
+```
+
+Correct:
+
+```ts
+const query = queryClient.getQueryCache().find({ queryKey })
+const observerStaleTimes = query?.observers.map(
+ (observer) => observer.options.staleTime,
+)
+```
+
+Several options are observer-level, so multiple components can observe the same query with different selectors or freshness behavior.
+
+Source: https://tkdodo.eu/blog/automatic-query-invalidation-after-mutations
+
+### MEDIUM Debugging without checking observer count
+
+Wrong:
+
+```ts
+queryClient.invalidateQueries({ queryKey: ['todos'] })
+// expect every cached todo query to refetch immediately
+```
+
+Correct:
+
+```ts
+queryClient.invalidateQueries({ queryKey: ['todos'], refetchType: 'active' })
+```
+
+Inactive queries are not automatically the same as mounted queries. Check observer count in devtools when invalidation or garbage collection looks surprising.
+
+Source: https://tkdodo.eu/blog/inside-react-query
diff --git a/packages/query-intent/skills/core/write-mutations-and-invalidate-related-queries/SKILL.md b/packages/query-intent/skills/core/write-mutations-and-invalidate-related-queries/SKILL.md
new file mode 100644
index 00000000000..316f6027916
--- /dev/null
+++ b/packages/query-intent/skills/core/write-mutations-and-invalidate-related-queries/SKILL.md
@@ -0,0 +1,184 @@
+---
+name: core/write-mutations-and-invalidate-related-queries
+description: >
+ Use this when writing server state with useMutation, mutationFn, mutate,
+ mutateAsync, mutationKey, useMutationState, invalidateQueries, setMutationDefaults,
+ awaited invalidation, and mutation callbacks.
+type: core
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/design-query-keys-and-options
+ - core/fetch-and-observe-queries
+sources:
+ - TanStack/query:docs/framework/react/guides/mutations.md
+ - TanStack/query:docs/framework/react/guides/query-invalidation.md
+ - TanStack/query:docs/framework/react/guides/invalidations-from-mutations.md
+ - TanStack/query:docs/framework/react/guides/updates-from-mutation-responses.md
+ - TanStack/query:docs/framework/react/reference/useMutation.md
+ - TanStack/query:docs/framework/react/reference/useMutationState.md
+ - TanStack/query:docs/reference/MutationCache.md
+---
+
+## Setup
+
+```ts
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+export function useAddTodo() {
+ const queryClient = useQueryClient()
+ return useMutation({
+ mutationFn: async (title: string) => ({ id: Date.now(), title }),
+ onSuccess: async () => {
+ await queryClient.invalidateQueries({ queryKey: ['todos'] })
+ },
+ })
+}
+```
+
+## Core Patterns
+
+### Update from mutation response
+
+```ts
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+export function useSaveTodo() {
+ const queryClient = useQueryClient()
+ return useMutation({
+ mutationFn: async (todo: { id: string; title: string }) => todo,
+ onSuccess: (todo) => {
+ queryClient.setQueryData(['todo', todo.id], todo)
+ },
+ })
+}
+```
+
+### Track related mutations
+
+```ts
+import { useMutationState } from '@tanstack/react-query'
+
+export function usePendingTodoTitles() {
+ return useMutationState({
+ filters: { mutationKey: ['addTodo'], status: 'pending' },
+ select: (mutation) => mutation.state.variables as string,
+ })
+}
+```
+
+### Scope defaults by mutation key
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+
+queryClient.setMutationDefaults(['addTodo'], {
+ mutationFn: async (title: string) => ({ id: Date.now(), title }),
+})
+```
+
+## Common Mistakes
+
+### HIGH Multiple mutate arguments
+
+Wrong:
+
+```ts
+import { useMutation } from '@tanstack/react-query'
+
+export function useUpdateTodo() {
+ return useMutation({
+ mutationFn: async (input: { id: string; title: string }) => input,
+ })
+}
+
+useUpdateTodo().mutate('1', 'Ship')
+```
+
+Correct:
+
+```ts
+import { useMutation } from '@tanstack/react-query'
+
+export function useUpdateTodo() {
+ return useMutation({
+ mutationFn: async (input: { id: string; title: string }) => input,
+ })
+}
+
+useUpdateTodo().mutate({ id: '1', title: 'Ship' })
+```
+
+Mutation variables are one value; pass an object when multiple fields are needed.
+
+Source: TanStack/query:docs/framework/react/guides/mutations.md
+
+### HIGH Per-call callback after unmount
+
+Wrong:
+
+```ts
+import { useMutation } from '@tanstack/react-query'
+
+export function useSave() {
+ return useMutation({ mutationFn: async (title: string) => title })
+}
+
+useSave().mutate('Ship', { onSuccess: () => console.log('saved') })
+```
+
+Correct:
+
+```ts
+import { useMutation } from '@tanstack/react-query'
+
+export function useSave() {
+ return useMutation({
+ mutationFn: async (title: string) => title,
+ onSuccess: () => console.log('saved'),
+ })
+}
+```
+
+Hook-level callbacks are tied to the mutation lifecycle; per-call callbacks may not run if the observer unmounts.
+
+Source: TanStack/query:docs/framework/react/guides/mutations.md
+
+### HIGH Not awaiting invalidation
+
+Wrong:
+
+```ts
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+export function useAddTodo() {
+ const queryClient = useQueryClient()
+ return useMutation({
+ mutationFn: async (title: string) => title,
+ onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+export function useAddTodo() {
+ const queryClient = useQueryClient()
+ return useMutation({
+ mutationFn: async (title: string) => title,
+ onSuccess: async () =>
+ queryClient.invalidateQueries({ queryKey: ['todos'] }),
+ })
+}
+```
+
+Returning the invalidation promise keeps the mutation pending until dependent data is refreshed.
+
+Source: TanStack/query:docs/framework/react/guides/invalidations-from-mutations.md
+
+See also: `core/implement-optimistic-updates-and-cache-writes` for mutation side effects that update the cache before the server returns.
diff --git a/packages/query-intent/skills/framework/debug-with-devtools/SKILL.md b/packages/query-intent/skills/framework/debug-with-devtools/SKILL.md
new file mode 100644
index 00000000000..d77a764affb
--- /dev/null
+++ b/packages/query-intent/skills/framework/debug-with-devtools/SKILL.md
@@ -0,0 +1,169 @@
+---
+name: framework/debug-with-devtools
+description: >
+ Use this when adding, lazy-loading, or debugging TanStack Query devtools:
+ ReactQueryDevtools, VueQueryDevtools, SolidQueryDevtools, SvelteQueryDevtools,
+ Angular devtools panel, embedded panels, production imports, cache inspection,
+ and offline misconceptions.
+type: framework
+library: TanStack Query
+framework: cross-adapter
+library_version: '5.101.0'
+requires:
+ - lifecycle/setup-query-client-and-providers
+sources:
+ - TanStack/query:docs/framework/react/devtools.md
+ - TanStack/query:docs/framework/preact/devtools.md
+ - TanStack/query:docs/framework/vue/devtools.md
+ - TanStack/query:docs/framework/solid/devtools.md
+ - TanStack/query:docs/framework/svelte/devtools.md
+ - TanStack/query:docs/framework/angular/devtools.md
+---
+
+This skill builds on `lifecycle/setup-query-client-and-providers`.
+
+## Setup
+
+```tsx
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+
+export function Devtools() {
+ return
+}
+```
+
+## Hooks and Components
+
+### Lazy-load production devtools
+
+```tsx
+import * as React from 'react'
+
+const ReactQueryDevtoolsProduction = React.lazy(() =>
+ import('@tanstack/react-query-devtools/production').then((module) => ({
+ default: module.ReactQueryDevtools,
+ })),
+)
+
+export function LazyDevtools() {
+ return (
+
+
+
+ )
+}
+```
+
+### Embed a panel
+
+```tsx
+import { ReactQueryDevtoolsPanel } from '@tanstack/react-query-devtools'
+
+export function DevtoolsPanel() {
+ return
+}
+```
+
+### Use adapter-specific packages
+
+```ts
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+import { VueQueryDevtools } from '@tanstack/vue-query-devtools'
+
+export const devtools = { ReactQueryDevtools, VueQueryDevtools }
+```
+
+## Common Mistakes
+
+### MEDIUM Eager production devtools
+
+Wrong:
+
+```tsx
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+
+export function AppDevtools() {
+ return
+}
+```
+
+Correct:
+
+```tsx
+import * as React from 'react'
+
+const Devtools = React.lazy(() =>
+ import('@tanstack/react-query-devtools/production').then((module) => ({
+ default: module.ReactQueryDevtools,
+ })),
+)
+export function AppDevtools() {
+ return (
+
+
+
+ )
+}
+```
+
+Production devtools should be lazy-loaded from the production entry.
+
+Source: TanStack/query:docs/framework/react/devtools.md
+
+### MEDIUM Mock offline misconception
+
+Wrong:
+
+```tsx
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+
+export function Devtools() {
+ return
+}
+```
+
+Correct:
+
+```ts
+import { onlineManager } from '@tanstack/react-query'
+
+export function setOfflineForTest() {
+ onlineManager.setOnline(false)
+}
+```
+
+Devtools inspect state; use Query managers or browser tooling to model network state.
+
+Source: TanStack/query:docs/reference/onlineManager.md
+
+### HIGH Devtools outside provider
+
+Wrong:
+
+```tsx
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+
+export function Root() {
+ return
+}
+```
+
+Correct:
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+
+const queryClient = new QueryClient()
+export function Root() {
+ return (
+
+
+
+ )
+}
+```
+
+Devtools need the same QueryClient context as the app.
+
+Source: TanStack/query:docs/framework/react/devtools.md
diff --git a/packages/query-intent/skills/framework/handle-status-and-errors/SKILL.md b/packages/query-intent/skills/framework/handle-status-and-errors/SKILL.md
new file mode 100644
index 00000000000..f831cac58b1
--- /dev/null
+++ b/packages/query-intent/skills/framework/handle-status-and-errors/SKILL.md
@@ -0,0 +1,131 @@
+---
+name: framework/handle-status-and-errors
+description: >
+ Use this when designing TanStack Query loading, empty, stale, background error,
+ retry, toast, throwOnError, and Error Boundary flows. Covers status versus
+ fetchStatus, stale data after failed refetches, global QueryCache or
+ MutationCache error callbacks, and local versus boundary-level error handling.
+type: framework
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/fetch-and-observe-queries
+ - framework/use-suspense-and-error-boundaries
+sources:
+ - https://tkdodo.eu/blog/status-checks-in-react-query
+ - https://tkdodo.eu/blog/react-query-error-handling
+ - TanStack/query:docs/framework/react/guides/queries.md
+ - TanStack/query:docs/framework/react/reference/QueryErrorResetBoundary.md
+---
+
+## Core Patterns
+
+Prefer data-first rendering when stale data is useful. A failed background refetch can produce `isError` while `data` is still available.
+
+```tsx
+const todos = useQuery({ queryKey: ['todos'], queryFn: fetchTodos })
+
+if (todos.data)
+ return
+if (todos.isPending) return
+if (todos.isError) return
+return null
+```
+
+Use `throwOnError` when render-time Error Boundaries should own the fallback:
+
+```tsx
+useQuery({
+ queryKey: ['todos'],
+ queryFn: fetchTodos,
+ throwOnError: (error) => error.status >= 500,
+})
+```
+
+Use global cache callbacks for cross-cutting notifications:
+
+```ts
+import { QueryCache, QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient({
+ queryCache: new QueryCache({
+ onError: (error, query) => {
+ if (query.state.data !== undefined) showToast(error.message)
+ },
+ }),
+})
+```
+
+## Common Mistakes
+
+### HIGH Hiding stale data on background error
+
+Wrong:
+
+```tsx
+if (query.isError) return
+if (query.data) return
+```
+
+Correct:
+
+```tsx
+if (query.data)
+ return (
+
+ )
+if (query.isError) return
+```
+
+Background refetch failures should not necessarily erase already-rendered data.
+
+Source: https://tkdodo.eu/blog/status-checks-in-react-query
+
+### HIGH Sending validation errors to a global boundary
+
+Wrong:
+
+```ts
+useMutation({ mutationFn: submitForm, throwOnError: true })
+```
+
+Correct:
+
+```ts
+useMutation({
+ mutationFn: submitForm,
+ throwOnError: (error) => error.status >= 500,
+})
+```
+
+Handle expected 4xx validation errors near the form. Send unexpected server failures to the boundary.
+
+Source: https://tkdodo.eu/blog/react-query-error-handling
+
+### MEDIUM Duplicating toast notifications per observer
+
+Wrong:
+
+```ts
+useQuery({
+ queryKey: ['todos'],
+ queryFn: fetchTodos,
+ onError: toastError,
+})
+```
+
+Correct:
+
+```ts
+new QueryClient({
+ queryCache: new QueryCache({
+ onError: (error, query) => {
+ if (query.state.data !== undefined) toastError(error)
+ },
+ }),
+})
+```
+
+Observer-level callbacks can duplicate notifications across components. Use cache-level callbacks for global side effects.
+
+Source: https://tkdodo.eu/blog/react-query-error-handling
diff --git a/packages/query-intent/skills/framework/shape-data-and-render-efficiently/SKILL.md b/packages/query-intent/skills/framework/shape-data-and-render-efficiently/SKILL.md
new file mode 100644
index 00000000000..d956b327c0a
--- /dev/null
+++ b/packages/query-intent/skills/framework/shape-data-and-render-efficiently/SKILL.md
@@ -0,0 +1,184 @@
+---
+name: framework/shape-data-and-render-efficiently
+description: >
+ Use this when optimizing TanStack Query rendering with structuralSharing,
+ tracked properties, select, notifyOnChangeProps, stable hook deps, immutable
+ data, Vue reactivity, and no-rest-destructuring or no-unstable-deps lint rules.
+type: framework
+library: TanStack Query
+framework: cross-adapter
+library_version: '5.101.0'
+requires:
+ - core/fetch-and-observe-queries
+ - core/seed-placeholder-select-and-transform-data
+sources:
+ - TanStack/query:docs/framework/react/guides/render-optimizations.md
+ - TanStack/query:docs/eslint/no-rest-destructuring.md
+ - TanStack/query:docs/eslint/no-unstable-deps.md
+ - TanStack/query:docs/framework/vue/reactivity.md
+---
+
+This skill builds on `core/fetch-and-observe-queries` and `core/seed-placeholder-select-and-transform-data`.
+
+## Setup
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function TodoCount() {
+ const { data } = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }, { id: 2 }],
+ select: (todos) => todos.length,
+ })
+ return {data ?? 0}
+}
+```
+
+## Hooks and Components
+
+### Destructure only used result fields
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const { data, isFetching } = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return (
+
+ {isFetching ? 'Refreshing ' : ''}
+ {JSON.stringify(data ?? [])}
+
+ )
+}
+```
+
+### Keep Vue query data immutable
+
+```ts
+import { ref } from 'vue'
+
+export function editableTodo(todo: { id: number; title: string }) {
+ return ref({ ...todo })
+}
+```
+
+### Use stable members in deps
+
+```tsx
+import * as React from 'react'
+import { useQuery } from '@tanstack/react-query'
+
+export function TodosEffect() {
+ const { data } = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ React.useEffect(() => console.log(data?.length ?? 0), [data])
+ return null
+}
+```
+
+## Common Mistakes
+
+### MEDIUM Rest destructuring
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ const { data, ...rest } = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return { data, rest }
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ const { data, isFetching, error } = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return { data, isFetching, error }
+}
+```
+
+Rest destructuring touches every tracked property and disables fine-grained render tracking.
+
+Source: TanStack/query:docs/eslint/no-rest-destructuring.md
+
+### HIGH Query result in hook deps
+
+Wrong:
+
+```tsx
+import * as React from 'react'
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const query = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ React.useEffect(() => console.log(query.data), [query])
+ return null
+}
+```
+
+Correct:
+
+```tsx
+import * as React from 'react'
+import { useQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const { data } = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ React.useEffect(() => console.log(data), [data])
+ return null
+}
+```
+
+The top-level query result object is not referentially stable; destructured members are tracked.
+
+Source: TanStack/query:docs/eslint/no-unstable-deps.md
+
+### HIGH Vue v-model mutates query result
+
+Wrong:
+
+```vue
+
+
+```
+
+Correct:
+
+```vue
+
+
+```
+
+Vue Query results are immutable; make a mutable copy for form state.
+
+Source: TanStack/query:docs/framework/vue/reactivity.md
+
+See also: `compositions/enforce-query-best-practices-with-eslint` for lint rules that protect render tracking.
diff --git a/packages/query-intent/skills/framework/use-framework-adapter-reactivity/SKILL.md b/packages/query-intent/skills/framework/use-framework-adapter-reactivity/SKILL.md
new file mode 100644
index 00000000000..2ee691daa7c
--- /dev/null
+++ b/packages/query-intent/skills/framework/use-framework-adapter-reactivity/SKILL.md
@@ -0,0 +1,185 @@
+---
+name: framework/use-framework-adapter-reactivity
+description: >
+ Use this when translating Query patterns across React, Preact, Vue, Solid,
+ Svelte, Angular, and Lit adapters: Vue refs/getters, Solid signals, Svelte
+ stores/runes, Angular signals and HttpClient promises, Lit QueryController,
+ adapter option helpers, and provider APIs.
+type: framework
+library: TanStack Query
+framework: cross-adapter
+library_version: '5.101.0'
+requires:
+ - lifecycle/setup-query-client-and-providers
+ - core/design-query-keys-and-options
+sources:
+ - TanStack/query:docs/framework/vue/reactivity.md
+ - TanStack/query:docs/framework/vue/guides/query-options.md
+ - TanStack/query:docs/framework/solid/guides/query-options.md
+ - TanStack/query:docs/framework/svelte/overview.md
+ - TanStack/query:docs/framework/svelte/migrate-from-v5-to-v6.md
+ - TanStack/query:docs/framework/angular/overview.md
+ - TanStack/query:docs/framework/angular/zoneless.md
+ - TanStack/query:docs/framework/lit/guides/reactive-controllers-vs-hooks.md
+---
+
+This skill builds on `lifecycle/setup-query-client-and-providers` and `core/design-query-keys-and-options`.
+
+## Setup
+
+```ts
+import { queryOptions } from '@tanstack/react-query'
+
+export function todoOptions(id: string) {
+ return queryOptions({
+ queryKey: ['todo', id],
+ queryFn: async () => ({ id }),
+ })
+}
+```
+
+## Hooks and Components
+
+### Keep Vue refs in the key
+
+```ts
+import { computed, toRef } from 'vue'
+import { useQuery } from '@tanstack/vue-query'
+
+export function useTodo(props: { id: string }) {
+ const id = toRef(props, 'id')
+ return useQuery(
+ computed(() => ({
+ queryKey: ['todo', id.value],
+ queryFn: async () => ({ id: id.value }),
+ })),
+ )
+}
+```
+
+### Use Solid option functions
+
+```ts
+import { createQuery } from '@tanstack/solid-query'
+
+export function useTodo(id: () => string) {
+ return createQuery(() => ({
+ queryKey: ['todo', id()],
+ queryFn: async () => ({ id: id() }),
+ }))
+}
+```
+
+### Convert Angular Observable clients to promises
+
+```ts
+import { injectQuery } from '@tanstack/angular-query-experimental'
+import { firstValueFrom, of } from 'rxjs'
+
+export class TodosQuery {
+ todos = injectQuery(() => ({
+ queryKey: ['todos'],
+ queryFn: () => firstValueFrom(of([{ id: 1 }])),
+ }))
+}
+```
+
+## Common Mistakes
+
+### HIGH Vue ref unwrapped
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/vue-query'
+
+export function useTodo(id: { value: string }) {
+ return useQuery({
+ queryKey: ['todo', id.value],
+ queryFn: async () => ({ id: id.value }),
+ })
+}
+```
+
+Correct:
+
+```ts
+import { computed } from 'vue'
+import { useQuery } from '@tanstack/vue-query'
+
+export function useTodo(id: { value: string }) {
+ return useQuery(
+ computed(() => ({
+ queryKey: ['todo', id.value],
+ queryFn: async () => ({ id: id.value }),
+ })),
+ )
+}
+```
+
+Vue reactive inputs need to stay reactive through the options object or query key.
+
+Source: TanStack/query:docs/framework/vue/reactivity.md
+
+### HIGH Svelte store syntax in v6
+
+Wrong:
+
+```svelte
+
+```
+
+Correct:
+
+```svelte
+
+```
+
+Svelte Query v6 uses rune-compatible option functions rather than the older store shape.
+
+Source: TanStack/query:docs/framework/svelte/migrate-from-v5-to-v6.md
+
+### HIGH Angular Observable returned directly
+
+Wrong:
+
+```ts
+import { injectQuery } from '@tanstack/angular-query-experimental'
+import { of } from 'rxjs'
+
+export class TodosQuery {
+ todos = injectQuery(() => ({
+ queryKey: ['todos'],
+ queryFn: () => of([{ id: 1 }]),
+ }))
+}
+```
+
+Correct:
+
+```ts
+import { injectQuery } from '@tanstack/angular-query-experimental'
+import { firstValueFrom, of } from 'rxjs'
+
+export class TodosQuery {
+ todos = injectQuery(() => ({
+ queryKey: ['todos'],
+ queryFn: () => firstValueFrom(of([{ id: 1 }])),
+ }))
+}
+```
+
+Query functions must resolve data; Angular HttpClient Observables need conversion to promises.
+
+Source: TanStack/query:docs/framework/angular/angular-httpclient-and-other-data-fetching-clients.md
+
+See also: `core/design-query-keys-and-options` for key identity across adapters.
diff --git a/packages/query-intent/skills/framework/use-suspense-and-error-boundaries/SKILL.md b/packages/query-intent/skills/framework/use-suspense-and-error-boundaries/SKILL.md
new file mode 100644
index 00000000000..12b9de00dd3
--- /dev/null
+++ b/packages/query-intent/skills/framework/use-suspense-and-error-boundaries/SKILL.md
@@ -0,0 +1,210 @@
+---
+name: framework/use-suspense-and-error-boundaries
+description: >
+ Use this when using useSuspenseQuery, useSuspenseQueries,
+ useSuspenseInfiniteQuery, QueryErrorResetBoundary, throwOnError,
+ useQueryErrorResetBoundary, React.use query.promise, streamed hydration, and
+ Suspense constraints in Query adapters.
+type: framework
+library: TanStack Query
+framework: cross-adapter
+library_version: '5.101.0'
+requires:
+ - core/fetch-and-observe-queries
+ - lifecycle/prefetch-and-remove-request-waterfalls
+sources:
+ - TanStack/query:docs/framework/react/guides/suspense.md
+ - TanStack/query:docs/framework/react/reference/QueryErrorResetBoundary.md
+ - TanStack/query:docs/framework/react/reference/useSuspenseQuery.md
+ - TanStack/query:docs/framework/react/reference/useSuspenseQueries.md
+ - TanStack/query:docs/framework/react/reference/useSuspenseInfiniteQuery.md
+ - TanStack/query:docs/framework/solid/guides/suspense.md
+ - TanStack/query:docs/framework/vue/guides/suspense.md
+---
+
+This skill builds on `core/fetch-and-observe-queries` and `lifecycle/prefetch-and-remove-request-waterfalls`.
+
+## Setup
+
+```tsx
+import { Suspense } from 'react'
+import { useSuspenseQuery } from '@tanstack/react-query'
+
+function Todos() {
+ const { data } = useSuspenseQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return {JSON.stringify(data)}
+}
+
+export function App() {
+ return (
+ Loading}>
+
+
+ )
+}
+```
+
+## Hooks and Components
+
+### Reset query errors with the boundary
+
+```tsx
+import { QueryErrorResetBoundary } from '@tanstack/react-query'
+import { ErrorBoundary } from 'react-error-boundary'
+
+export function QueryErrorBoundary(props: { children: React.ReactNode }) {
+ return (
+
+ {({ reset }) => (
+ (
+
+ )}
+ >
+ {props.children}
+
+ )}
+
+ )
+}
+```
+
+### Use suspense when data must be defined
+
+```ts
+import { useSuspenseQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useSuspenseQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+}
+```
+
+### Use normal queries for disabled flows
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useMaybeTodo(id: string | undefined) {
+ return useQuery({
+ queryKey: ['todo', id],
+ queryFn: async () => ({ id }),
+ enabled: Boolean(id),
+ })
+}
+```
+
+## Common Mistakes
+
+### HIGH Disabled suspense query
+
+Wrong:
+
+```ts
+import { useSuspenseQuery } from '@tanstack/react-query'
+
+export function useTodo(id: string | undefined) {
+ return useSuspenseQuery({
+ queryKey: ['todo', id],
+ queryFn: async () => ({ id }),
+ enabled: Boolean(id),
+ })
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodo(id: string | undefined) {
+ return useQuery({
+ queryKey: ['todo', id],
+ queryFn: async () => ({ id }),
+ enabled: Boolean(id),
+ })
+}
+```
+
+Suspense hooks guarantee `data` and do not support conditional disabling like normal queries.
+
+Source: TanStack/query:docs/framework/react/guides/suspense.md
+
+### HIGH Missing reset boundary
+
+Wrong:
+
+```tsx
+import { useSuspenseQuery } from '@tanstack/react-query'
+
+export function Todos() {
+ const { data } = useSuspenseQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return {JSON.stringify(data)}
+}
+```
+
+Correct:
+
+```tsx
+import { QueryErrorResetBoundary } from '@tanstack/react-query'
+import { ErrorBoundary } from 'react-error-boundary'
+
+export function WrappedTodos(props: { children: React.ReactNode }) {
+ return (
+
+ {({ reset }) => (
+ Error}>
+ {props.children}
+
+ )}
+
+ )
+}
+```
+
+Error boundaries need Query reset coordination so failed queries can retry after reset.
+
+Source: TanStack/query:docs/framework/react/reference/QueryErrorResetBoundary.md
+
+### MEDIUM query.promise without flag
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodoPromise() {
+ return useQuery({ queryKey: ['todo', 1], queryFn: async () => ({ id: 1 }) })
+ .promise
+}
+```
+
+Correct:
+
+```ts
+import { QueryClient, useQuery } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: { queries: { experimental_prefetchInRender: true } },
+})
+
+export function useTodoPromise() {
+ return useQuery({ queryKey: ['todo', 1], queryFn: async () => ({ id: 1 }) })
+ .promise
+}
+```
+
+The stable `promise` property requires the experimental prefetch-in-render flag.
+
+Source: TanStack/query:docs/framework/react/guides/suspense.md
+
+See also: `lifecycle/ssr-hydration-and-streaming` for streamed hydration constraints.
diff --git a/packages/query-intent/skills/lifecycle/migrate-major-versions-and-codemods/SKILL.md b/packages/query-intent/skills/lifecycle/migrate-major-versions-and-codemods/SKILL.md
new file mode 100644
index 00000000000..5c6b04a5b8b
--- /dev/null
+++ b/packages/query-intent/skills/lifecycle/migrate-major-versions-and-codemods/SKILL.md
@@ -0,0 +1,169 @@
+---
+name: lifecycle/migrate-major-versions-and-codemods
+description: >
+ Use this when migrating TanStack Query across React Query v3, React Query v4,
+ TanStack Query v5, Vue Query v5, Svelte Query v6, removed overloads,
+ object syntax, cacheTime to gcTime, removed query callbacks, keepPreviousData
+ migration, and query-codemods.
+type: lifecycle
+library: TanStack Query
+library_version: '5.101.0'
+sources:
+ - TanStack/query:docs/framework/react/guides/migrating-to-react-query-3.md
+ - TanStack/query:docs/framework/react/guides/migrating-to-react-query-4.md
+ - TanStack/query:docs/framework/react/guides/migrating-to-v5.md
+ - TanStack/query:docs/framework/vue/guides/migrating-to-v5.md
+ - TanStack/query:docs/framework/svelte/migrate-from-v5-to-v6.md
+ - TanStack/query:packages/query-codemods/package.json
+---
+
+## Setup
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ gcTime: 5 * 60 * 1000,
+ })
+}
+```
+
+## Core Patterns
+
+### Use object syntax everywhere
+
+```ts
+import { QueryClient, useQuery } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+export function useTodo(id: string) {
+ return useQuery({ queryKey: ['todo', id], queryFn: async () => ({ id }) })
+}
+
+export function prefetchTodo(id: string) {
+ return queryClient.prefetchQuery({
+ queryKey: ['todo', id],
+ queryFn: async () => ({ id }),
+ })
+}
+```
+
+### Rename cacheTime to gcTime
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: { queries: { gcTime: 10 * 60 * 1000 } },
+})
+```
+
+### Migrate keepPreviousData
+
+```ts
+import { keepPreviousData, useQuery } from '@tanstack/react-query'
+
+export function usePage(page: number) {
+ return useQuery({
+ queryKey: ['page', page],
+ queryFn: async () => ({ page }),
+ placeholderData: keepPreviousData,
+ })
+}
+```
+
+## Common Mistakes
+
+### CRITICAL v4 overload syntax
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery(['todos'], async () => [{ id: 1 }])
+}
+```
+
+Correct:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery({ queryKey: ['todos'], queryFn: async () => [{ id: 1 }] })
+}
+```
+
+v5 removed hook and client overloads in favor of a single object signature.
+
+Source: TanStack/query:docs/framework/react/guides/migrating-to-v5.md
+
+### HIGH Removed query callbacks
+
+Wrong:
+
+```ts
+import { useQuery } from '@tanstack/react-query'
+
+export function useTodos() {
+ return useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ onSuccess: () => console.log('loaded'),
+ })
+}
+```
+
+Correct:
+
+```tsx
+import * as React from 'react'
+import { useQuery } from '@tanstack/react-query'
+
+export function TodosLogger() {
+ const { data } = useQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ React.useEffect(() => {
+ if (data) console.log('loaded')
+ }, [data])
+ return null
+}
+```
+
+v5 removed query callbacks from queries; react to data changes outside the query options.
+
+Source: TanStack/query:docs/framework/react/guides/migrating-to-v5.md
+
+### HIGH cacheTime in v5
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: { queries: { cacheTime: 60_000 } },
+})
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: { queries: { gcTime: 60_000 } },
+})
+```
+
+`cacheTime` was renamed to `gcTime` to describe garbage collection of unused queries.
+
+Source: TanStack/query:docs/framework/react/guides/migrating-to-v5.md
diff --git a/packages/query-intent/skills/lifecycle/prefetch-and-remove-request-waterfalls/SKILL.md b/packages/query-intent/skills/lifecycle/prefetch-and-remove-request-waterfalls/SKILL.md
new file mode 100644
index 00000000000..f4429b916b9
--- /dev/null
+++ b/packages/query-intent/skills/lifecycle/prefetch-and-remove-request-waterfalls/SKILL.md
@@ -0,0 +1,228 @@
+---
+name: lifecycle/prefetch-and-remove-request-waterfalls
+description: >
+ Use this when flattening request waterfalls with prefetchQuery,
+ prefetchInfiniteQuery, ensureQueryData, fetchQuery, usePrefetchQuery,
+ usePrefetchInfiniteQuery, route loaders, TanStack Router loaders, Start routes,
+ Suspense prefetching, and query-function prefetching.
+type: lifecycle
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - core/design-query-keys-and-options
+ - core/fetch-and-observe-queries
+ - core/tune-defaults-freshness-retries-and-refetching
+sources:
+ - TanStack/query:docs/framework/react/guides/prefetching.md
+ - TanStack/query:docs/framework/react/guides/request-waterfalls.md
+ - TanStack/query:docs/framework/react/reference/usePrefetchQuery.md
+ - TanStack/query:docs/framework/react/reference/usePrefetchInfiniteQuery.md
+ - TanStack/query:docs/reference/QueryClient.md
+ - TanStack/query:examples/react/react-router/src/routes/root.tsx
+ - TanStack/query:examples/react/react-router/src/routes/contact.tsx
+---
+
+## Setup
+
+```ts
+import { QueryClient, queryOptions } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+const todosOptions = queryOptions({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1, title: 'Ship' }],
+ staleTime: 60_000,
+})
+
+export function preloadTodos() {
+ return queryClient.prefetchQuery(todosOptions)
+}
+```
+
+## Core Patterns
+
+### Use loaders for route-critical data
+
+```ts
+import { QueryClient, queryOptions } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+const contactOptions = (contactId: string) =>
+ queryOptions({
+ queryKey: ['contact', contactId],
+ queryFn: async () => ({ id: contactId, name: 'Ada' }),
+ })
+
+export function contactLoader(contactId: string) {
+ return queryClient.ensureQueryData(contactOptions(contactId))
+}
+```
+
+### Prefetch before Suspense can suspend
+
+```tsx
+import { Suspense } from 'react'
+import { usePrefetchQuery, useSuspenseQuery } from '@tanstack/react-query'
+
+const commentsOptions = {
+ queryKey: ['comments'],
+ queryFn: async () => [{ id: 1 }],
+}
+
+function Comments() {
+ const { data } = useSuspenseQuery(commentsOptions)
+ return {JSON.stringify(data)}
+}
+
+export function CommentsSection() {
+ usePrefetchQuery(commentsOptions)
+ return (
+ Loading}>
+
+
+ )
+}
+```
+
+### Pick the right client method
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+
+export function getTodo(id: string) {
+ return queryClient.fetchQuery({
+ queryKey: ['todo', id],
+ queryFn: async () => ({ id }),
+ })
+}
+```
+
+Use `fetchQuery` when the caller needs data or thrown errors; use `prefetchQuery` when it only needs to warm the cache.
+
+## Common Mistakes
+
+### HIGH Expecting prefetchQuery to return data
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+const data = await queryClient.prefetchQuery({
+ queryKey: ['todo', 1],
+ queryFn: async () => ({ id: 1 }),
+})
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+const data = await queryClient.fetchQuery({
+ queryKey: ['todo', 1],
+ queryFn: async () => ({ id: 1 }),
+})
+```
+
+`prefetchQuery` returns void and swallows errors; `fetchQuery` returns data and throws.
+
+Source: TanStack/query:docs/framework/react/guides/prefetching.md
+
+### HIGH Prefetch staleTime only set on prefetch
+
+Wrong:
+
+```ts
+import { QueryClient, useQuery } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+await queryClient.prefetchQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ staleTime: 60_000,
+})
+export function useTodos() {
+ return useQuery({ queryKey: ['todos'], queryFn: async () => [{ id: 1 }] })
+}
+```
+
+Correct:
+
+```ts
+import { QueryClient, queryOptions, useQuery } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+const options = queryOptions({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ staleTime: 60_000,
+})
+await queryClient.prefetchQuery(options)
+export function useTodos() {
+ return useQuery(options)
+}
+```
+
+Prefetch call options do not automatically configure the later observer.
+
+Source: TanStack/query:docs/framework/react/guides/prefetching.md
+
+### HIGH Suspense prefetch after suspension
+
+Wrong:
+
+```tsx
+import * as React from 'react'
+import { useQueryClient, useSuspenseQuery } from '@tanstack/react-query'
+
+export function Article() {
+ const queryClient = useQueryClient()
+ const article = useSuspenseQuery({
+ queryKey: ['article'],
+ queryFn: async () => ({ id: 1 }),
+ })
+ React.useEffect(() => {
+ queryClient.prefetchQuery({
+ queryKey: ['comments'],
+ queryFn: async () => [],
+ })
+ }, [queryClient])
+ return {JSON.stringify(article.data)}
+}
+```
+
+Correct:
+
+```tsx
+import { Suspense } from 'react'
+import { usePrefetchQuery, useSuspenseQuery } from '@tanstack/react-query'
+
+function Article() {
+ const article = useSuspenseQuery({
+ queryKey: ['article'],
+ queryFn: async () => ({ id: 1 }),
+ })
+ return {JSON.stringify(article.data)}
+}
+
+export function ArticleRoute() {
+ usePrefetchQuery({ queryKey: ['comments'], queryFn: async () => [] })
+ return (
+ Loading}>
+
+
+ )
+}
+```
+
+Effects do not run until after a suspenseful query resolves, so they cannot flatten that waterfall.
+
+Source: TanStack/query:docs/framework/react/guides/prefetching.md
+
+See also: `compositions/compose-query-with-tanstack-router-and-start` for Router and Start loader prefetching.
diff --git a/packages/query-intent/skills/lifecycle/setup-query-client-and-providers/SKILL.md b/packages/query-intent/skills/lifecycle/setup-query-client-and-providers/SKILL.md
new file mode 100644
index 00000000000..62132cf734b
--- /dev/null
+++ b/packages/query-intent/skills/lifecycle/setup-query-client-and-providers/SKILL.md
@@ -0,0 +1,177 @@
+---
+name: lifecycle/setup-query-client-and-providers
+description: >
+ Use this when creating a TanStack Query QueryClient, QueryClientProvider, VueQueryPlugin,
+ provideTanStackQuery, Svelte QueryClientProvider, Angular providers, Lit controllers, or
+ SSR request-local clients. Covers stable client lifetime and provider wiring.
+type: lifecycle
+library: TanStack Query
+library_version: '5.101.0'
+sources:
+ - TanStack/query:docs/framework/react/quick-start.md
+ - TanStack/query:docs/framework/react/reference/QueryClientProvider.md
+ - TanStack/query:docs/eslint/stable-query-client.md
+ - TanStack/query:docs/framework/vue/guides/custom-client.md
+ - TanStack/query:docs/framework/angular/overview.md
+ - TanStack/query:docs/framework/lit/guides/reactive-controllers-vs-hooks.md
+---
+
+## Setup
+
+```tsx
+import * as React from 'react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+export function AppProviders(props: { children: React.ReactNode }) {
+ const [queryClient] = React.useState(() => new QueryClient())
+ return (
+
+ {props.children}
+
+ )
+}
+```
+
+## Core Patterns
+
+### Create request-local SSR clients
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export function createServerQueryClient() {
+ return new QueryClient({
+ defaultOptions: { queries: { staleTime: 60_000 } },
+ })
+}
+```
+
+### Use adapter-native providers
+
+```ts
+import { QueryClient } from '@tanstack/query-core'
+
+export function createQueryClient() {
+ return new QueryClient({
+ defaultOptions: { queries: { retry: 2 } },
+ })
+}
+```
+
+React and Preact use `QueryClientProvider`; Vue uses `VueQueryPlugin`; Angular uses `provideTanStackQuery`; Svelte and Lit use their adapter provider/controller APIs.
+
+### Pass an explicit client at integration boundaries
+
+```ts
+import { QueryClient } from '@tanstack/query-core'
+
+const queryClient = new QueryClient()
+
+export function getTodos() {
+ return queryClient.ensureQueryData({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1, title: 'Ship' }],
+ })
+}
+```
+
+## Common Mistakes
+
+### CRITICAL New client on every render
+
+Wrong:
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+export function App(props: { children: React.ReactNode }) {
+ const queryClient = new QueryClient()
+ return (
+
+ {props.children}
+
+ )
+}
+```
+
+Correct:
+
+```tsx
+import * as React from 'react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+export function App(props: { children: React.ReactNode }) {
+ const [queryClient] = React.useState(() => new QueryClient())
+ return (
+
+ {props.children}
+
+ )
+}
+```
+
+Recreating the client discards caches and subscriptions on render.
+
+Source: TanStack/query:docs/eslint/stable-query-client.md
+
+### CRITICAL Shared SSR cache between users
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export function createRequestQueryClient() {
+ return new QueryClient()
+}
+```
+
+A module-level server client can leak one request's cached data into another request.
+
+Source: TanStack/query:docs/framework/react/guides/ssr.md
+
+### HIGH Ambiguous Lit fallback client
+
+Wrong:
+
+```ts
+import { QueryController } from '@tanstack/lit-query'
+
+export class TodoElement extends HTMLElement {
+ todos = new QueryController(this, {
+ queryKey: ['todos'],
+ queryFn: async () => [],
+ })
+}
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/query-core'
+import { QueryController } from '@tanstack/lit-query'
+
+const queryClient = new QueryClient()
+
+export class TodoElement extends HTMLElement {
+ todos = new QueryController(
+ this,
+ { queryKey: ['todos'], queryFn: async () => [] },
+ queryClient,
+ )
+}
+```
+
+Lit controllers need a clear provider or explicit client when the element is not under a provider tree.
+
+Source: TanStack/query:docs/framework/lit/guides/reactive-controllers-vs-hooks.md
+
+See also: `lifecycle/ssr-hydration-and-streaming` for server cache handoff.
diff --git a/packages/query-intent/skills/lifecycle/ssr-hydration-and-streaming/SKILL.md b/packages/query-intent/skills/lifecycle/ssr-hydration-and-streaming/SKILL.md
new file mode 100644
index 00000000000..5e5adac7b48
--- /dev/null
+++ b/packages/query-intent/skills/lifecycle/ssr-hydration-and-streaming/SKILL.md
@@ -0,0 +1,229 @@
+---
+name: lifecycle/ssr-hydration-and-streaming
+description: >
+ Use this when implementing SSR, hydration, dehydrate, hydrate,
+ HydrationBoundary, TanStack Start, TanStack Router SSR Query, Next.js app
+ router, Next.js pages router, React Server Components, SvelteKit, Nuxt,
+ SolidStart, Lit SSR, ReactQueryStreamedHydration, or streamedQuery.
+type: lifecycle
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - lifecycle/setup-query-client-and-providers
+ - lifecycle/prefetch-and-remove-request-waterfalls
+sources:
+ - TanStack/query:docs/framework/react/guides/ssr.md
+ - TanStack/query:docs/framework/react/guides/advanced-ssr.md
+ - TanStack/query:docs/framework/react/reference/hydration.md
+ - TanStack/query:docs/reference/environmentManager.md
+ - TanStack/query:docs/reference/streamedQuery.md
+ - TanStack/query:docs/framework/vue/guides/ssr.md
+ - TanStack/query:docs/framework/svelte/ssr.md
+ - TanStack/query:docs/framework/solid/guides/ssr.md
+ - TanStack/query:docs/framework/lit/guides/ssr.md
+---
+
+## Setup
+
+```tsx
+import {
+ HydrationBoundary,
+ QueryClient,
+ dehydrate,
+} from '@tanstack/react-query'
+
+export async function PostsPage() {
+ const queryClient = new QueryClient()
+ await queryClient.prefetchQuery({
+ queryKey: ['posts'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return (
+
+
+
+ )
+}
+
+function Posts() {
+ return Hydrated posts render here
+}
+```
+
+## Core Patterns
+
+### Put TanStack Start and Router first
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+import { createRouter } from '@tanstack/react-router'
+import { setupRouterSsrQueryIntegration } from '@tanstack/react-router-ssr-query'
+import { routeTree } from './routeTree.gen'
+
+const queryClient = new QueryClient()
+const router = createRouter({ routeTree, context: { queryClient } })
+
+setupRouterSsrQueryIntegration({ router, queryClient })
+```
+
+### Use per-request clients
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export function createSsrQueryClient() {
+ return new QueryClient({
+ defaultOptions: { queries: { staleTime: 60_000 } },
+ })
+}
+```
+
+### Hydrate only prefetched data
+
+```tsx
+import {
+ HydrationBoundary,
+ QueryClient,
+ dehydrate,
+} from '@tanstack/react-query'
+
+export async function Page() {
+ const queryClient = new QueryClient()
+ await queryClient.prefetchQuery({
+ queryKey: ['profile'],
+ queryFn: async () => ({ name: 'Tanner' }),
+ })
+ return (
+
+ Profile
+
+ )
+}
+```
+
+## Common Mistakes
+
+### CRITICAL RSC renders fetched data twice
+
+Wrong:
+
+```tsx
+import {
+ HydrationBoundary,
+ QueryClient,
+ dehydrate,
+} from '@tanstack/react-query'
+
+export async function Page() {
+ const queryClient = new QueryClient()
+ const posts = await queryClient.fetchQuery({
+ queryKey: ['posts'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return (
+ <>
+ {posts.length}
+
+ Posts
+
+
+ )
+}
+```
+
+Correct:
+
+```tsx
+import {
+ HydrationBoundary,
+ QueryClient,
+ dehydrate,
+} from '@tanstack/react-query'
+
+export async function Page() {
+ const queryClient = new QueryClient()
+ await queryClient.prefetchQuery({
+ queryKey: ['posts'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return (
+
+ Posts
+
+ )
+}
+```
+
+Server-rendered derived data can desynchronize from client-refetched Query data.
+
+Source: TanStack/query:docs/framework/react/guides/advanced-ssr.md
+
+### CRITICAL Suspense query not prefetched on server
+
+Wrong:
+
+```tsx
+import { useSuspenseQuery } from '@tanstack/react-query'
+
+export function Posts() {
+ const { data } = useSuspenseQuery({
+ queryKey: ['posts'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return {JSON.stringify(data)}
+}
+```
+
+Correct:
+
+```tsx
+import {
+ HydrationBoundary,
+ QueryClient,
+ dehydrate,
+} from '@tanstack/react-query'
+
+export async function Page() {
+ const queryClient = new QueryClient()
+ await queryClient.prefetchQuery({
+ queryKey: ['posts'],
+ queryFn: async () => [{ id: 1 }],
+ })
+ return (
+
+ Posts
+
+ )
+}
+```
+
+A suspense query that is not prefetched can fetch on the server, fail to hydrate, then fetch again on the client.
+
+Source: TanStack/query:docs/framework/react/guides/ssr.md
+
+### HIGH SvelteKit query runs after SSR response
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/svelte-query'
+
+export const queryClient = new QueryClient()
+```
+
+Correct:
+
+```ts
+import { browser } from '$app/environment'
+import { QueryClient } from '@tanstack/svelte-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: { queries: { enabled: browser } },
+})
+```
+
+SvelteKit SSR needs browser-gated default query execution unless server data is explicitly prefetched.
+
+Source: TanStack/query:docs/framework/svelte/ssr.md
+
+See also: `compositions/compose-query-with-tanstack-router-and-start` for TanStack-owned SSR routing.
diff --git a/packages/query-intent/skills/lifecycle/test-query-code/SKILL.md b/packages/query-intent/skills/lifecycle/test-query-code/SKILL.md
new file mode 100644
index 00000000000..3c686c055f6
--- /dev/null
+++ b/packages/query-intent/skills/lifecycle/test-query-code/SKILL.md
@@ -0,0 +1,164 @@
+---
+name: lifecycle/test-query-code
+description: >
+ Use this when testing TanStack Query code with isolated QueryClient instances,
+ test providers, retry false, cache cleanup, async assertions, hook testing,
+ React/Vue/Solid/Angular harnesses, and deterministic query state.
+type: lifecycle
+library: TanStack Query
+library_version: '5.101.0'
+requires:
+ - lifecycle/setup-query-client-and-providers
+ - core/tune-defaults-freshness-retries-and-refetching
+sources:
+ - TanStack/query:docs/framework/react/guides/testing.md
+ - TanStack/query:docs/framework/solid/guides/testing.md
+ - TanStack/query:docs/framework/vue/guides/testing.md
+ - TanStack/query:docs/framework/angular/guides/testing.md
+ - TanStack/query:packages/query-core/src/__tests__/queryClient.test.tsx
+ - TanStack/query:packages/react-query/src/__tests__/useQuery.test.tsx
+---
+
+## Setup
+
+```tsx
+import * as React from 'react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+export function createTestWrapper() {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ })
+
+ return function TestWrapper(props: { children: React.ReactNode }) {
+ return (
+
+ {props.children}
+
+ )
+ }
+}
+```
+
+## Core Patterns
+
+### Create a client per test
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export function createTestQueryClient() {
+ return new QueryClient({
+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+ })
+}
+```
+
+### Await async state
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export async function loadTodosForTest() {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ })
+ return queryClient.fetchQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+ })
+}
+```
+
+### Clear after direct client tests
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export function dispose(queryClient: QueryClient) {
+ queryClient.clear()
+}
+```
+
+## Common Mistakes
+
+### CRITICAL Shared test client
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export function createQueryClient() {
+ return new QueryClient({ defaultOptions: { queries: { retry: false } } })
+}
+```
+
+A shared client leaks cache and mutation state across tests.
+
+Source: TanStack/query:docs/framework/react/guides/testing.md
+
+### HIGH Retry backoff in tests
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient()
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+export const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+})
+```
+
+Default retries delay failure and make tests look hung.
+
+Source: TanStack/query:docs/framework/react/guides/testing.md
+
+### HIGH Asserting before async success
+
+Wrong:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+const promise = queryClient.fetchQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+})
+console.log(queryClient.getQueryData(['todos']))
+await promise
+```
+
+Correct:
+
+```ts
+import { QueryClient } from '@tanstack/react-query'
+
+const queryClient = new QueryClient()
+await queryClient.fetchQuery({
+ queryKey: ['todos'],
+ queryFn: async () => [{ id: 1 }],
+})
+console.log(queryClient.getQueryData(['todos']))
+```
+
+Query state is asynchronous; assert after the query promise resolves or the UI wait completes.
+
+Source: TanStack/query:docs/framework/react/guides/testing.md
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 859c42dd7a9..c1f750a5057 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -49,6 +49,12 @@ importers:
'@tanstack/eslint-config':
specifier: 0.3.2
version: 0.3.2(@typescript-eslint/utils@8.58.1(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.4(jiti@2.6.1))(typescript@5.9.3)
+ '@tanstack/intent':
+ specifier: ^0.0.41
+ version: 0.0.41
+ '@tanstack/query-intent':
+ specifier: workspace:*
+ version: link:packages/query-intent
'@tanstack/typedoc-config':
specifier: 0.3.1
version: 0.3.1(typescript@5.9.3)
@@ -2765,6 +2771,12 @@ importers:
specifier: ^2.11.6
version: 2.11.11(@testing-library/jest-dom@6.9.1)(solid-js@1.9.12)(vite@6.4.1(@types/node@22.19.15)(jiti@2.6.1)(lightningcss@1.32.0)(sass@1.90.0)(terser@5.46.1)(tsx@4.21.0)(yaml@2.8.3))
+ packages/query-intent:
+ devDependencies:
+ '@tanstack/intent':
+ specifier: ^0.0.41
+ version: 0.0.41
+
packages/query-persist-client-core:
dependencies:
'@tanstack/query-core':
@@ -7288,6 +7300,10 @@ packages:
resolution: {integrity: sha512-2g+PuGR3GuvvCiR3xZs+IMqAvnYU9bvH+jRml0BFBSxHBj22xFCTNvJWhvgj7uICFF9IchDkFUto91xDPMu5cg==}
engines: {node: '>=18'}
+ '@tanstack/intent@0.0.41':
+ resolution: {integrity: sha512-Psl+oDiidLvtctswkTQ1P6sQIihwrMLcdfQVfkLpO42oKwxWEr1lodWUHiOG5jFXsGwDDvpUv/WAdlmJF+yGpw==}
+ hasBin: true
+
'@tanstack/match-sorter-utils@8.19.4':
resolution: {integrity: sha512-Wo1iKt2b9OT7d+YGhvEPD3DXvPv2etTusIMhMUoG7fbhmxcXCtIjJDEygy91Y2JFlwGyjqiBPRozme7UD8hoqg==}
engines: {node: '>=12'}
@@ -21160,6 +21176,13 @@ snapshots:
- supports-color
- typescript
+ '@tanstack/intent@0.0.41':
+ dependencies:
+ cac: 6.7.14
+ jsonc-parser: 3.3.1
+ semver: 7.7.4
+ yaml: 2.8.3
+
'@tanstack/match-sorter-utils@8.19.4':
dependencies:
remove-accents: 0.5.0