NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
pub.dev · #218 most downloaded on pub.dev
A reactive caching and data-binding framework. Riverpod makes working with asynchronous code a breeze.
Last release 1 months ago
03 Sep 2026
Ships fairly regularly
a new release about every 5 weeks
Nearly every release is documented
notes for 55 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
6 years old
130 releases · first in 2020
One column per quarter.
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Removed an assert preventing from overriding the same provider/family multiple times on a ProviderScope/ProviderContainer.
Removed an assert preventing from overriding the same provider/family
multiple times on a ProviderScope/ProviderContainer.
Nothing published for this version
Fixed a null exception on web
Fixed a null exception on web
Improved the performance of the assert which verifies that providers properly respect their dependencies variable.
Improved the performance of the assert which verifies that providers properly
respect their dependencies variable.
ProviderListener is deprecated in favor of ref.listen.
Riverpod is now stable!
Breaking: ProviderContainer.debugProviderValues and ProviderContainer.debugProviderElements are removed.
You can now instead use ProviderContainer.getAllProviderElements.
ChangeNotifierProvider now supports nullable ChangeNotifier (#856)
Increased minimum SDK version to 2.14.0
Breaking The return value when reading a StateProvider changed.
Before, doing ref.read(someStateProvider) would return the StateController instance.
Now, this will only return the state of the StateController.
This new behavior matches StateNotifierProvider.
For a simple migration, the old behavior is available by writing
ref.read(someStateProvider.state).
Added ref.listen for triggering actions inside providers/widgets when a provider changes.
It can be used to listen to another provider without recreating the provider state:
final counterProvider = StateNotifierProvider<Counter, int>(...);
final anotherProvider = Provider<T>((ref) {
ref.listen<int>(counterProvider, (previous, count) {
print('counter changed from $previous to $count');
});
});
Alternatively, it can be used by widgets to show modals/dialogs:
final counterProvider = StateNotifierProvider<Counter, int>(...);
class Example extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
ref.listen<int>(counterProvider, (previous, count) {
showDialog(...);
});
}
}
ProviderListener is deprecated in favor of ref.listen.
It is now possible to "await" all providers that emit an AsyncValue (previously limited to FutureProvider/StreamProvider).
This includes cases where a StateNotifierProvider exposes an AsyncValue:
class MyAsyncStateNotifier extends StateNotifier<AsyncValue<MyState>> {
MyAsyncStateNotifier(): super(AsyncValue.loading()) {
// TODO fetch some data and update the state when it is obtained
}
}
final myAsyncStateNotifierProvider = StateNotifierProvider<MyAsyncStateNotifier, AsyncValue<MyState>>((ref) {
return MyAsyncStateNotifier();
});
final someFutureProvider = FutureProvider((ref) async {
MyState myState = await ref.watch(myAsyncStateNotifierProvider.future);
});
Deprecated StreamProvider.last in favor of StreamProvider.future.
StreamProvider.future, StreamProvider.stream and FutureProvider.future now
expose a future/stream that is independent from how many times the associated provider "rebuilt":
StreamProvider rebuild before its stream emitted any value,
StreamProvider.future will resolve with the first value of the new stream instead.FutureProvider rebuild before its future completes,
FutureProvider.future will resolve with the result of the new future instead.You can now override any provider with any other provider, as long as the value
that they expose matches. For example, it is possible to override a StreamProvider<Model>
with a Provider<AsyncValue<Model>>.
ref.onDispose now calls the dispose function as soon as one of the provider's
dependency is known to have changed
Providers can now call ref.refresh to refresh a provider, instead of having
to do ref.container.refresh.
Providers no longer wait until their next read to recompute their state if one of their dependency changed and they have listeners.
Added ProviderContainer.pump, a utility to easily "await" until providers
notify their listeners or are disposed.
fixed an issue when using both family and autoDispose that could lead to an inconsistent state
Breaking: The prototype of ConsumerWidget's build and Consumer's builder changed.
Before:
class Example extends ConsumerWidget {
@override
Widget build(BuildContext context, ScopedReader watch) {
int count = watch(counterProvider);
...
}
}
After:
class Example extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
int count = ref.watch(counterProvider);
...
}
}
ProviderListener is deprecated. Instead, use ref.listen:
class Example extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
ref.listen<int>(counter, (count) {
print('count changed $count');
});
}
}
Added ConsumerStatefulWidget + ConsumerState, a variant of
StatefulWidgets that have access to a WidgetRef.
All "watch" functions now support myProvider.select((value) => ...).
This allows filtering rebuilds:
final userProvider = StateNotifierProvider<UserController, User>(...);
Consumer(
builder: (context, ref, _) {
// With this syntax, the Consumer will not rebuild if `userProvider`
// emits a new User but its "name" didn't change.
bool userName = ref.watch(userProvider.select((user) => user.name));
},
)
ProviderReference is deprecated in favor of Ref.
Breaking: ProviderObserver.didUpdateProvider now receives both the previous and new value.
Breaking: ProviderObserver.mayHaveChanged is removed.
Breaking: Family.overrideWithProvider now must create a provider:
final family = Provider.family<State, Arg>(...);
family.overrideWithProvider(
(Arg arg) => Provider<State>((ref) => ...)
);
All providers now receive a custom subclass of ProviderRefBase as a parameter:
Provider<T>((ProviderRef<T> ref) {...});
FutureProvider<T>((FutureProviderRef<T> ref) {...});
StateProvider<T>((StateProviderRef<T> ref) {...});
That allows providers to implement features that is not shared with other providers.
Provider, FutureProvider and StreamProvider's ref now have a state property,
which represents the currently exposed value. Modifying it will notify the listeners:
Provider<int>((ref) {
ref.listen(onIncrementProvider, (_) {
ref.state++;
});
return 0;
});
StateProvider's ref now has a controller property, which allows the
provider to access the StateController exposed.
Breaking: ProviderReference.mounted is removed. You can implement something similar using onDispose:
Provider<T>((ref) {
var mounted = true;
ref.onDispose(() => mounted = false);
});
Breaking: ScopedProvider is removed.
To migrate, change ScopedProviders to Providers.
All providers now come with an extra named parameter called dependencies.
This parameter optionally allows defining the list of providers/families that this
new provider depends on:
final a = Provider(...);
final b = Provider((ref) => ref.watch(a), dependencies: [a]);
By doing so, this will tell Riverpod to automatically override b if a gets overridden.
AsyncValue:Breaking AsyncValue.copyWith is removed
Breaking AsyncValue.error(..., stacktrace) is now a named parameter instead of positional parameter.
Deprecated AsyncValue.data in favor of AsyncValue.value
Allowed AsyncData, AsyncError and AsyncLoading to be extended
Added AsyncValue.whenOrNull, similar to whenOrElse but instead of an
"orElse" parameter, returns null.
Added AsyncValue.value, which allows reading the value without handling
loading/error states.
AsyncError can now be instantiated with const.
Added StateController.update, to simplify updating the state from the previous state:
final provider = StateController((ref) => 0);
...
ref.read(provider).update((state) => state + 1);
It is no longer allowed to use ref.watch or ref.read inside a selector:
provider.select((value) => ref.watch(something)); // KO, cannot user ref.watch inside selectors
FutureProvider now creates a FutureOr<T> instead of a Future<T>.
That allows bypassing the loading state in the event where a value was synchronously available.
Fixed an issue where dependencies did not work for ChangeNotifierProvider
Fixed an issue where dependencies did not work for ChangeNotifierProvider (#800)
Fixed a bug where reading a provider within a consumer could throw
Fixed a bug where reading a provider within a consumer could throw (#796)
Fix an issue where *Provider.autoDispose were not able to specify the dependencies parameter.
Fix an issue where *Provider.autoDispose were not able to specify the
dependencies parameter.
Deprecated AsyncValue.data in favor of AsyncValue.value
FutureProvider now creates a FutureOr<T> instead of a Future<T>
That allows bypassing the loading state in the event where a value was synchronously available.
During loading and error states, FutureProvider and StreamProvider now expose the
latest value through AsyncValue.
That allows UI to show the previous data while some new data is loading,
instead of showing a spinner:
final provider = FutureProvider<User>((ref) async {
ref.watch(anotherProvider); // may cause `provider` to rebuild
return fetchSomething();
})
...
Widget build(context, ref) {
return ref.watch(provider).when(
error: (err, stack, _) => Text('error'),
data: (user) => Text('Hello ${user.name}'),
loading: (previous) {
if (previous is AsyncData<User>) {
return Text('loading ... (previous: ${previous.value.name})');
}
return CircularProgressIndicator();
}
);
}
AsyncValue.copyWith is removedAsyncValue.error(..., stacktrace) is now a named parameter instead of positional parameter.AsyncValue.when(loading: ) and AsyncValue.when(error: ) (and when variants)
now receive an extra "previous" parameter.AsyncValue.data in favor of AsyncValue.valueAsyncData, AsyncError and AsyncLoading to be extendedAsyncValue.whenOrNull, similar to whenOrElse but instead of an
"orElse" parameter, returns null.AsyncValue.value, which allows reading the value without handling
loading/error states.AsyncError can now be instantiated with const.AsyncLoading and AsyncError now optionally includes the previous state.Breaking All overrideWithProvider methods are removed.
To migrate, instead use overrideWithValue.
All providers now come with an extra named parameter called dependencies.
This parameter optionally allows defining the list of providers/families that this
new provider depends on:
final a = Provider(...);
final b = Provider((ref) => ref.watch(a), dependencies: [a]);
By doing so, this will tell Riverpod to automatically override b if a gets overridden.
Added StateController.update, to simplify updating the state from the previous state:
final provider = StateController((ref) => 0);
...
ref.read(provider).update((state) => state + 1);
It is no longer allowed to use ref.watch or ref.read inside a selector:
provider.select((value) => ref.watch(something)); // KO, cannot user ref.watch inside selectors
ref.listen now working when downcasing the value of a provider.ProviderContainer could cause other
ProviderContainers to stop working.Fixed ProviderObserver not working when modifying a StateProvider.
ProviderObserver not working when modifying a StateProvider.FIX: StreamProvider.last no longer throws a StateError when no value were emitted (#296).
ref.refresh not working on some providersProviderBase.recreateShouldNotify to updateShouldNotifyFixed an issue where provider listeners could not be called properly.
Fixed an issue where provider listeners could not be called properly.
Fixed various issues related to scoped providers.
Fixed various issues related to scoped providers.
All providers can now be scoped.
ScopedProvider is removed. To migrate, change ScopedProviders to Providers.- Add missing exports (see #532)
ProviderListener is deprecated. Instead, use ref.listen:
Breaking: The prototype of ConsumerWidget's build and Consumer's builder changed.
Before:
class Example extends ConsumerWidget {
@override
Widget build(BuildContext context, ScopedReader watch) {
int count = watch(counterProvider);
...
}
}
After:
class Example extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
int count = ref.watch(counterProvider);
...
}
}
ProviderListener is deprecated. Instead, use ref.listen:
class Example extends ConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
ref.listen<int>(counter, (count) {
print('count changed $count');
});
}
}
Added ConsumerStatefulWidget + ConsumerState, a variant of
StatefulWidgets that have access to a WidgetRef.
All "watch" functions now support myProvider.select((value) => ...).
This allows filtering rebuilds:
final userProvider = StateNotifierProvider<UserController, User>(...);
Consumer(
builder: (context, ref, _) {
// With this syntax, the Consumer will not rebuild if `userProvider`
// emits a new User but its "name" didn't change.
bool userName = ref.watch(userProvider.select((user) => user.name));
},
)
Breaking: Family.overrideWithProvider now must create a provider:
final family = Provider.family<State, Arg>(...);
family.overrideWithProvider(
(Arg arg) => Provider<State>((ref) => ...)
);
Breaking: ProviderObserver.didUpdateProvider now receives both the previous and new value.
Breaking: ProviderObserver.mayHaveChanged is removed.
Added ref.listen, used to listen to another provider without recreating the provider state:
final counter = StateNotifierProvider<Counter, int>(...);
final anotherProvider = Provider<T>((ref) {
ref.listen<int>(counter, (count) {
print('counter change: $count');
});
});
ProviderReference is deprecated in favor of ProviderRefBase.
All providers now receive a custom subclass of ProviderRefBase as a parameter:
Provider<T>((ProviderRef<T> ref) {...});
FutureProvider<T>((FutureProviderRef<T> ref) {...});
StateProvider<T>((StateProviderRef<T> ref) {...});
That allows providers to implement features that is not shared with other providers.
Provider, FutureProvider and StreamProvider's ref now have a state property,
which represents the currently exposed value. Modifying it will notify the listeners:
Provider<int>((ref) {
ref.listen(onIncrementProvider, (_) {
ref.state++;
});
return 0;
});
StateProvider's ref now has a controller property, which allows the
provider to access the StateController exposed.
Breaking: ProviderReference.mounted is removed. You can implement something similar using onDispose:
Provider<T>((ref) {
var mounted = true;
ref.onDispose(() => mounted = false);
});
Breaking: ProviderContainer.debugProviderValues and ProviderContainer.debugProviderElements are removed.
You can now instead use ProviderContainer.getAllProviderElements.
StreamProvider.last, StreamProvider.stream and FutureProvider.future now
expose a future/stream that is independent from how many times the associated provider "rebuilt":
StreamProvider rebuild before its stream emitted any value,
StreamProvider.last will resolve with the first value of the new stream instead.FutureProvider rebuild before its future completes,
FutureProvider.future will resolve with the result of the new future instead.You can now override any provider with any other provider, as long as the value
that they expose matches. For example, it is possible to override a StreamProvider<Model>
with a Provider<AsyncValue<Model>>.
Providers can now call ref.refresh to refresh a provider, instead of having
to do ref.container.refresh.
ref.onDispose now calls the dispose function as soon as one of the provider's
dependency is known to have changed
Providers no longer wait until their next read to recompute their state if one of their dependency changed and they have listeners.
Added ProviderContainer.pump, a utility to easily "await" until providers
notify their listeners or are disposed.
fixed an issue when using both family and autoDispose that could lead to an inconsistent state
BREAKING CHANGE The Listener/LocatorMixin typedefs are removed as the former could cause a name conflict with the widget named Listener and the latter…
BREAKING CHANGE The Listener/LocatorMixin typedefs are removed as the former could cause a name
conflict with the widget named Listener and the latter is not supported when using Riverpod.
BREAKING CHANGE The syntax for using StateNotifierProvider was updated.
Before:
class MyStateNotifier extends StateNotifier<MyModel> {...}
final provider = StateNotifierProvider<MyStateNotifier>((ref) => MyStateNotifier());
...
Widget build(context, watch) {
MyStateNotifier notifier = watch(provider);
MyModel model = watch(provider.state);
}
After:
class MyStateNotifier extends StateNotifier<MyModel> {...}
final provider = StateNotifierProvider<MyStateNotifier, MyModel>>((ref) => MyStateNotifier());
...
Widget build(context, watch) {
MyStateNotifier notifier = watch(provider.notifier);
MyModel model = watch(provider);
}
See also https://github.com/rrousselGit/riverpod/issues/341 for more information.
BREAKING CHANGE It is no longer possible to override StreamProvider.stream/last and FutureProvider.future.
feat: Calling ProviderContainer.dispose multiple time no longer throws.
This simplifies the tear-off logic of tests.
feat: Added ChangeNotifierProvider.notifier and StateProvider.notifier
They allow obtaining the notifier associated with the provider, without causing widgets/providers to rebuild when the state updates.
fix: overriding a StateNotifierProvider/ChangeNotifierProvider with overrideWithValue now correctly listens to the notifier.
Re-added StateProvider.overrideWithValue/StateProvider.overrideWithProvider that were involuntarily removed.
StateProvider.overrideWithValue/StateProvider.overrideWithProvider that were involuntarily removed.Fix context.refresh not compiling when using nullable providers
context.refresh not compiling when using nullable providersRemoved an assert that could cause issues when an application is partially migrated to null safety.
Removed an assert that could cause issues when an application is partially migrated to null safety.
Fixed a bug where overriding a FutureProvider with an error value could cause tests to fail (see https://github.com/rrousselGit/riverpod/issues/355)
FutureProvider with an error value could cause tests to fail (see https://github.com/rrousselGit/riverpod/issues/355)Fixed an issue where context.read and ProviderListener were unable to read providers that return a nullable value
Fixed an issue where context.read and ProviderListener were unable to read providers that return a nullable value
deprecated import 'flutter_riverpod/all.dart'. Now everything is available with flutter_riverpod/flutter_riverpod.dart.
ProviderObserver can now have a const constructorfreezed_annotationimport 'flutter_riverpod/all.dart'. Now everything is available with flutter_riverpod/flutter_riverpod.dart.StreamProvider.last could result in a StateError (#217)build method completed.
This allows "watch" to be used inside ListView.builder.context.read(myProvider) now accepts ScopeProvidersdeprecated import 'flutter_riverpod/all.dart'. Now everything is available with flutter_riverpod/flutter_riverpod.dart.
import 'flutter_riverpod/all.dart'. Now everything is available with flutter_riverpod/flutter_riverpod.dart.build method completed.
This allows "watch" to be used inside ListView.builder.context.read(myProvider) now accepts ScopeProviders- Fixed outdated doc
Fixed a but where listening to StreamProvider.last could result in a StateError
StreamProvider.last could result in a StateError (#217)Migrated to null-safety
Migrated to null-safety
Nothing published for this version
Nothing published for this version
Nothing published for this version
Exported AutoDisposeProviderRefBase
AutoDisposeProviderRefBaseFixed an remaining memory leak related to StreamProvider (see also https://github.com/rrousselGit/riverpod/issues/193)
Breaking FutureProvider and StreamProvider no longer supports null as a valid value.
null as a valid value.Fixed a bug where providers (usually ScopedProviders) did not dispose correctly (see also https://github.com/rrousselGit/riverpod/issues/154).
Fixed a bug where hot-reload did not work for ConsumerWidget/Consumer
ConsumerWidget/Consumerpackage:flutter_riverpod/flutter_riverpod.dart now exports StateNotifier
package:flutter_riverpod/flutter_riverpod.dart now exports StateNotifier@sealed so that the IDE warns against
implementing/subclassing providers.AsyncValue.guard's documentation (thanks @mono0926)freezed_annotation to support 0.12.0- Fixed invalid version error
Fixed a bug where the state of a provider may be disposed when it shouldn't be disposed.
Fixed a bug where the state of a provider may be disposed when it shouldn't be disposed.
Added a way to import the implementation class of providers with modifiers,
such as AutoDisposeProvider.
This is useful if you want to use Riverpod with the lint always_specify_types:
import 'package:flutter_riverpod/all.dart';
final AutoDisposeStateProvider<int> counter = StateProvider.autoDispose<int>((ProviderRefBase ref) {
return 0;
});
If you do not use this lint, prefer using the default import instead, to not pollute your auto-complete.
Nothing published for this version
Breaking Updating ProviderListener so that onChange receives the BuildContext as a parameter (thanks to @tbm98)
ProviderListener so that onChange receives the
BuildContext as a parameter (thanks to @tbm98)Renamed ProviderContainer.debugProviderStates to ProviderContainer.debugProviderElements
ProviderContainer.debugProviderStates to ProviderContainer.debugProviderElementsProviderScope.overrides may cause an exception
for no reason (see https://github.com/rrousselGit/riverpod/issues/107)Fixed a bug that prevented the use of ConsumerWidget under normal circumstances
Fixed a bug that prevented the use of ConsumerWidget under normal circumstances
Fixed a bug where in release mode, ScopedProvider did not update correctly
ScopedProvider did not update correctly (https://github.com/rrousselGit/riverpod/issues/101)Breaking: Consumer is slightly modified to match other Builders like ValueListenableBuilder. Before:
Breaking: Consumer is slightly modified to match other Builders like
ValueListenableBuilder.
Before:
return Consumer((context, watch) {
final value = watch(myProvider);
return Text('$value');
});
after:
return Consumer(
builder: (context, watch, child) {
final value = watch(myProvider);
return Text('$value');
},
);
Added a ConsumerWidget class which can be extended to make a StatelessWidget
that can read providers:
class MyWidget extends ConsumerWidget {
const MyWidget({Key? key}) : super(key: key);
@override
Widget build(BuildContext context, ScopedReader watch) {
final value = watch(myProvider);
return Text('$value');
}
}
ref.watch on non ".autoDispose" providers can no longer read ".autoDispose"
providers.
For more info, see http://riverpod.dev/docs/concepts/modifiers/auto_dispose#the-argument-type-autodisposeprovider-cant-be-assigned-to-the-parameter-type-alwaysaliveproviderbase
ScopedProvider now accepts null as a function:
final example = ScopedProvider<int>(null);
Which is equivalent to:
final example = ScopedProvider<int>((watch) => throw UnimplementedError(''));
Fixed a bug where context.refresh may not work properly if the widget tree
contains multiple ProviderScope.
Fixed a bug where when disposing ProviderContainer, providers may be disposed in an incorrect order.
ProviderContainer, providers may be disposed
in an incorrect order.Merged Computed and Provider. Now, all providers have the ability to rebuild their state when one of the object they listen changed.
Merged Computed and Provider. Now, all providers have the ability to rebuild
their state when one of the object they listen changed.
To migrate, change:
final provider = Provider(...);
final example = Computed((watch) {
final value = watch(provider);
return value;
});
into:
final provider = Provider(...);
final example = Provider((ref) {
final value = ref.watch(provider);
return value;
});
Computed (now Provider) no longer deeply compare collections to avoid rebuilds.
Comparing the content of lists is quite expensive and actually rarely useful.
Now, a simple == comparison is used.
Renamed ProviderStateOwner to ProviderContainer
Renamed ProviderStateOwnerObserver to ProviderObserver
It is no longer possible to override a provider anywhere in the widget tree.
Providers can only be overridden in the top-most ProviderScope/ProviderContainer.
Providers can now read values which may change over time using ref.read and ref.watch.
When using ref.watch, if the value obtained changes, this will cause the provider
to re-create its state.
It is no longer possible to add ProviderObserver anywhere in the widget tree.
They can be added only on the top-most ProviderScope/ProviderContainer.
Provider.read(BuildContext) is changed into context.read(provider), and
can now read Provider.autoDispose.
Added ProviderContainer.refresh(provider) and context.refresh(provider).
These method allows forcing the refresh of a provider, which can be useful
for things like "retry on error" or "pull to refresh".
ref.read(StreamProvider<T>) no longer returns a Stream<T> but an AsyncValue<T>
Before:
final streamProvider = StreamProvider<T>(...);
final example = Provider((ref) {
Stream<T> stream = ref.read(streamProvider);
});
After:
final streamProvider = StreamProvider<T>(...);
final example = Provider((ref) {
Stream<T> stream = ref.watch(streamProvider.steam);
});
ref.read(FutureProvider<T>) no longer returns a Future<T> but an AsyncValue<T>
Before:
final futureProvider = FutureProvider<T>(...);
final example = Provider((ref) {
Future<T> future = ref.read(futureProvider);
});
After:
final futureProvider = FutureProvider<T>(...);
final example = Provider((ref) {
Future<T> future = ref.watch(futureProvider.future);
});
Removed ref.dependOn.
You can now use ref.read/ref.watch to achieve the same effect.
Before:
final streamProvider = StreamProvider<T>(...);
final example = Provider((ref) {
Future<T> last = ref.dependOn(streamProvider).last;
});
After:
final streamProvider = StreamProvider<T>(...);
final example = Provider((ref) {
Future<T> last = ref.watch(streamProvider.last);
});
Provider.readOwner(ProviderStateOwner) is changed into ProviderContainer.read(Provider)
Provider.watchOwner(ProviderStateOwner, (value) {}) is changed into:
ProviderContainer container;
final provider = Provider((ref) => 0);
final subscription = container.listen(
provider,
mayHaveChanged: (sub) {},
didChange: (sub) {}.
);
subscription.close();
MyProvider.family.autoDispose now correctly free both the arguments and the associated
providers from memory when the provider is no longer listened to.
Added ScopedProvider, a new kind of provider that can be overridden anywhere
in the widget tree.
Normal providers cannot read a ScopedProvider.
Added ProviderListener, a widget which allows listening to a provider
without rebuilding the widget-tree. This can be useful for showing modals
and pushing routes.
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Your coding agent can read these notes before it upgrades. Set up the MCP server →