queryCache.findAll() returns wrapped iterable instead of array — breaks standard invalidation APIs

[nicolas-chalet-wmx]

Environment:

• @tanstack/react-query v5.90.2
• React 18.2.0
• Issue occurs in mobile WebViews only, not in Electron

Description:

We're building a library that uses react-query and is consumed by a host application. In certain build configurations (mobile WebViews), we observe unexpected behavior:

const queryCache = useQueryClient().getQueryCache();
const queries = queryCache.findAll();

// Expected: Query[]
// Actual: An array with a single iterable entry that yields Query objects

We suspect this is due to module duplication where our library and the host app resolve to different instances of @tanstack/react-query.

Impact:

Due to this issue, we cannot use the standard react-query APIs for cache management:

// ❌ These do NOT work in our mobile environment:
queryClient.invalidateQueries({ queryKey: ['myKey'] });
queryClient.resetQueries({ queryKey: ['myKey'] });
queryClient.clear();

// ✅ We have to manually iterate and call methods on each Query instance:
const queries = queryCache.findAll();
const normalized = normalizeIterableResult(queries); // our workaround

normalized.forEach((query) => {
  query.invalidate();
  query.reset();
  // or query.fetch() for refetch
});

This forces us to bypass the intended API and work directly with Query instances, which feels brittle and may break with future versions.

Questions:

1. Is this a known behavior when multiple instances coexist?
2. Are there recommended bundler configurations to prevent this?
3. Should react-query detect this scenario and warn developers?
4. Is working directly with Query.invalidate() / Query.reset() / Query.fetch() a supported pattern, or are we relying on internal implementation details?

Workaround:

We currently normalize the result by checking if the first element is iterable:

const normalizeQuery = (maybeNotQuery: Query): Query[] => {
  const isIterator = Symbol.iterator in Object(maybeNotQuery);
  if (isIterator) {
    return [...maybeNotQuery as Iterable<Query>];
  }
  return [maybeNotQuery];
};

const queries = queryCache.findAll().flatMap(normalizeQuery);