Why do autoDispose providers get disposed after the first await when read via .future?

[BolaAshEf]

Hi 👋
I’m running into something with container.read the future of FutureProvider.autoDispose and I’d like to clarify if this is expected behavior or a bug.

Mininal Example

final userProvider = FutureProvider.autoDispose.family<User, String>((ref, userId) async {
  ref.onDispose(() => print('disposed $userId'));

  await Future.delayed(const Duration(milliseconds: 500));
  return User(userId, 'User $userId');
});

final usersProvider = FutureProvider.autoDispose<List<User>>((ref) async {
  final userA = await ref.watch(userProvider('a').future);
  final userB = await ref.watch(userProvider('b').future);
  final userC = await ref.watch(userProvider('c').future);

  return [userA, userB, userC];
});

void main() async {
  final container = ProviderContainer();
  final users = await container.read(usersProvider.future);
  print(users);
  container.dispose();
}

Observed

The usersProvider is disposed right after the first await in usersProvider, rendering its ref being not mounted, so the next ref.watch errors:

UnmountedRefException (Cannot use the Ref of FutureProvider<List<User>>#b60f2 after it has been disposed. This typically happens if:
- A provider rebuilt, but the previous "build" was still pending and is still performing operations.
  You should therefore either use `ref.onDispose` to cancel pending work, or
  check `ref.mounted` after async gaps or anything that could invalidate the provider.
- You tried to use Ref inside `onDispose` or other life-cycles.
  This is not supported, as the provider is already being disposed.
)

Expected (my assumption)

Since I am reading usersProvider.future, I expect it to keepalive until the future(or its build) completes.

Workaround

• Listen to usersProvider.future
• Wait until the first future is emitted.
• Await the resulting future.
• Cancel the listener.

This works for now.

[jwson-automation]

If you wanted to write test code, you can manage it somehow with container.listen.

Since the Future Provider is calling other providers sequentially, it appears to be normal behavior for it to be disposed before the asynchronous processing completes.