chore(release): publish packages

- cherrypick@3.0.0-dev.2
 - cherrypick_flutter@1.1.3-dev.2

CHANGELOG.md

@@ -3,6 +3,65 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2025-08-04
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - [`cherrypick` - `v3.0.0-dev.2`](#cherrypick---v300-dev2)
+
+Packages with other changes:
+
+ - [`cherrypick_flutter` - `v1.1.3-dev.2`](#cherrypick_flutter---v113-dev2)
+
+Packages with dependency updates only:
+
+> Packages listed below depend on other packages in this workspace that have had changes. Their versions have been incremented to bump the minimum dependency versions of the packages they depend upon in this project.
+
+ - `cherrypick_flutter` - `v1.1.3-dev.2`
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.2`
+
+ - **FEAT**(binding): add deprecated proxy async methods for backward compatibility and highlight transition to modern API.
+ - **DOCS**: add quick guide for circular dependency detection to README.
+ - **DOCS**: add quick guide for circular dependency detection to README.
+ - **BREAKING** **FEAT**: implement comprehensive circular dependency detection system.
+ - **BREAKING** **FEAT**: implement comprehensive circular dependency detection system.
+
+
+## 2025-07-30
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.1`](#cherrypick---v300-dev1)
+ - [`cherrypick_flutter` - `v1.1.3-dev.1`](#cherrypick_flutter---v113-dev1)
+
+Packages with dependency updates only:
+
+> Packages listed below depend on other packages in this workspace that have had changes. Their versions have been incremented to bump the minimum dependency versions of the packages they depend upon in this project.
+
+ - `cherrypick_flutter` - `v1.1.3-dev.1`
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.1`
+
+ - **DOCS**: add quick guide for circular dependency detection to README.
+
+
 ## 2025-07-30
 
 ### Changes

benchmark_cherrypick/README.md

@@ -0,0 +1,42 @@
+# benchmark_cherrypick
+
+Benchmarks for performance and features of the cherrypick (core) DI container.
+
+All scenarios use the public API capabilities of cherrypick (scope, module, binding, scoping, and async support).
+
+## Scenarios
+
+- **RegisterAndResolve**: basic registration and resolution of a dependency.
+- **ChainSingleton (A->B->C, singleton)**: dependency chain, all as singletons.
+- **ChainFactory (A->B->C, factory)**: dependency chain with factory bindings (new instance on each request).
+- **NamedResolve (by name)**: resolving a named dependency among multiple implementations.
+- **AsyncChain (A->B->C, async)**: asynchronous dependency chain.
+- **ScopeOverride (child overrides parent)**: overriding a dependency in a child scope over a parent.
+
+## Benchmark results
+
+| Scenario                                           | RunTime (μs)  |
+|----------------------------------------------------|---------------|
+| RegisterAndResolve                                 | 0.4574        |
+| ChainSingleton (A->B->C, singleton)                | 0.3759        |
+| ChainFactory (A->B->C, factory)                    | 1.3783        |
+| NamedResolve (by name)                             | 0.5193        |
+| AsyncChain (A->B->C, async)                        | 0.5985        |
+| ScopeOverride (child overrides parent)             | 0.3611        |
+
+## How to run
+
+1. Get dependencies:
+   ```shell
+   dart pub get
+   ```
+2. Run the benchmarks:
+   ```shell
+   dart run bin/main.dart
+   ```
+
+A text report with all metrics will be displayed in the console.
+
+---
+
+To add your custom scenario — just create a new Dart file and declare a class extending BenchmarkBase or AsyncBenchmarkBase, then add its invocation to main.dart.

benchmark_cherrypick/README.ru.md

@@ -0,0 +1,42 @@
+# benchmark_cherrypick
+
+Бенчмарки производительности и функциональности DI-контейнера cherrypick (core).
+
+Все сценарии используют реальные возможности public API cherrypick (scope, module, binding, scoping и асинхронность).
+
+## Сценарии
+
+- **RegisterAndResolve**: базовая операция регистрации и разрешения зависимости.
+- **ChainSingleton (A->B->C, singleton)**: цепочка зависимостей, все singletons.
+- **ChainFactory (A->B->C, factory)**: цепочка зависимостей с factory биндингами, новые объекты на каждый запрос.
+- **NamedResolve (by name)**: разрешение именованной зависимости среди нескольких реализаций.
+- **AsyncChain (A->B->C, async)**: асинхронная цепочка зависимостей.
+- **ScopeOverride (child overrides parent)**: переопределение зависимости в дочернем scope над родительским.
+
+## Результаты исследования
+
+| Сценарий                                           | RunTime (мкс) |
+|----------------------------------------------------|--------------|
+| RegisterAndResolve                                 | 0.4574        |
+| ChainSingleton (A->B->C, singleton)                | 0.3759        |
+| ChainFactory (A->B->C, factory)                    | 1.3783        |
+| NamedResolve (by name)                             | 0.5193        |
+| AsyncChain (A->B->C, async)                        | 0.5985        |
+| ScopeOverride (child overrides parent)             | 0.3611        |
+
+## Как запускать
+
+1. Получить зависимости:
+   ```shell
+   dart pub get
+   ```
+2. Запустить бенчмарк:
+   ```shell
+   dart run bin/main.dart
+   ```
+
+Будет показан текстовый отчёт по всем метрикам.
+
+---
+
+Если хотите добавить свой сценарий — создайте отдельный Dart-файл и объявите новый BenchmarkBase/AsyncBenchmarkBase, не забудьте вставить его вызов в main.

benchmark_cherrypick/analysis_options.yaml

@@ -0,0 +1,33 @@
+# This file configures the static analysis results for your project (errors,
+# warnings, and lints).
+#
+# This enables the 'recommended' set of lints from `package:lints`.
+# This set helps identify many issues that may lead to problems when running
+# or consuming Dart code, and enforces writing Dart using a single, idiomatic
+# style and format.
+#
+# If you want a smaller set of lints you can change this to specify
+# 'package:lints/core.yaml'. These are just the most critical lints
+# (the recommended set includes the core lints).
+# The core lints are also what is used by pub.dev for scoring packages.
+
+include: package:lints/recommended.yaml
+analyzer:
+  errors:
+    deprecated_member_use: ignore
+
+# Uncomment the following section to specify additional rules.
+
+# linter:
+#   rules:
+#     - camel_case_types
+
+# analyzer:
+#   exclude:
+#     - path/to/excluded/files/**
+
+# For more information about the core and recommended set of lints, see
+# https://dart.dev/go/core-lints
+
+# For additional information about configuring this file, see
+# https://dart.dev/guides/language/analysis-options

benchmark_cherrypick/bin/main.dart

@@ -0,0 +1,17 @@
+import 'package:benchmark_cherrypick/cherrypick_benchmark.dart';
+import 'package:benchmark_cherrypick/complex_bindings_benchmark.dart';
+import 'package:benchmark_cherrypick/async_chain_benchmark.dart';
+import 'package:benchmark_cherrypick/scope_override_benchmark.dart';
+
+void main(List<String> args) async {
+  // Синхронные бенчмарки
+  RegisterAndResolveBenchmark().report();
+  ChainSingletonBenchmark().report();
+  ChainFactoryBenchmark().report();
+  NamedResolveBenchmark().report();
+
+  // Асинхронный бенчмарк
+  await AsyncChainBenchmark().report();
+
+  ScopeOverrideBenchmark().report();
+}

benchmark_cherrypick/lib/async_chain_benchmark.dart

@@ -0,0 +1,43 @@
+// ignore: depend_on_referenced_packages
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:cherrypick/cherrypick.dart';
+
+class AsyncA {}
+class AsyncB {
+  final AsyncA a;
+  AsyncB(this.a);
+}
+class AsyncC {
+  final AsyncB b;
+  AsyncC(this.b);
+}
+
+class AsyncChainModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<AsyncA>().toProvideAsync(() async => AsyncA()).singleton();
+    bind<AsyncB>().toProvideAsync(() async => AsyncB(await currentScope.resolveAsync<AsyncA>())).singleton();
+    bind<AsyncC>().toProvideAsync(() async => AsyncC(await currentScope.resolveAsync<AsyncB>())).singleton();
+  }
+}
+
+class AsyncChainBenchmark extends AsyncBenchmarkBase {
+  AsyncChainBenchmark() : super('AsyncChain (A->B->C, async)');
+  late Scope scope;
+
+  @override
+  Future<void> setup() async {
+    CherryPick.disableGlobalCycleDetection();
+    CherryPick.disableGlobalCrossScopeCycleDetection();
+    scope = CherryPick.openRootScope();
+    scope.installModules([AsyncChainModule()]);
+  }
+  @override
+  Future<void> teardown() async {
+    CherryPick.closeRootScope();
+  }
+  @override
+  Future<void> run() async {
+    await scope.resolveAsync<AsyncC>();
+  }
+}

benchmark_cherrypick/lib/cherrypick_benchmark.dart

@@ -0,0 +1,40 @@
+// ignore: depend_on_referenced_packages
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:cherrypick/cherrypick.dart';
+
+class AppModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+      bind<FooService>().toProvide(() => FooService());
+  }
+
+}
+
+// Dummy service for DI
+class FooService {}
+
+class RegisterAndResolveBenchmark extends BenchmarkBase {
+  RegisterAndResolveBenchmark() : super('RegisterAndResolve');
+  late final Scope scope;
+
+  @override
+  void setup() {
+    CherryPick.disableGlobalCycleDetection();
+    CherryPick.disableGlobalCrossScopeCycleDetection();
+    scope = CherryPick.openRootScope();
+    scope.installModules([AppModule()]);
+
+  }
+
+  @override
+  void run() {
+    scope.resolve<FooService>();
+  }
+
+  @override
+  void teardown() => CherryPick.closeRootScope();
+}
+
+void main() {
+  RegisterAndResolveBenchmark().report();
+}

benchmark_cherrypick/lib/complex_bindings_benchmark.dart

@@ -0,0 +1,95 @@
+// ignore: depend_on_referenced_packages
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:cherrypick/cherrypick.dart';
+
+// === DI graph: A -> B -> C (singleton) ===
+class ServiceA {}
+class ServiceB {
+  final ServiceA a;
+  ServiceB(this.a);
+}
+class ServiceC {
+  final ServiceB b;
+  ServiceC(this.b);
+}
+
+class ChainSingletonModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<ServiceA>().toProvide(() => ServiceA()).singleton();
+    bind<ServiceB>().toProvide((() => ServiceB(currentScope.resolve<ServiceA>()))).singleton();
+    bind<ServiceC>().toProvide((() => ServiceC(currentScope.resolve<ServiceB>()))).singleton();
+  }
+}
+
+class ChainSingletonBenchmark extends BenchmarkBase {
+  ChainSingletonBenchmark() : super('ChainSingleton (A->B->C, singleton)');
+  late Scope scope;
+  @override
+  void setup() {
+    scope = CherryPick.openRootScope();
+    scope.installModules([ChainSingletonModule()]);
+  }
+  @override
+  void teardown() => CherryPick.closeRootScope();
+  @override
+  void run() {
+    scope.resolve<ServiceC>();
+  }
+}
+
+// === DI graph: A -> B -> C (factory/no singleton) ===
+class ChainFactoryModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<ServiceA>().toProvide(() => ServiceA());
+    bind<ServiceB>().toProvide((() => ServiceB(currentScope.resolve<ServiceA>())));
+    bind<ServiceC>().toProvide((() => ServiceC(currentScope.resolve<ServiceB>())));
+  }
+}
+
+class ChainFactoryBenchmark extends BenchmarkBase {
+  ChainFactoryBenchmark() : super('ChainFactory (A->B->C, factory)');
+  late Scope scope;
+  @override
+  void setup() {
+    CherryPick.disableGlobalCycleDetection();
+    CherryPick.disableGlobalCrossScopeCycleDetection();
+    scope = CherryPick.openRootScope();
+    scope.installModules([ChainFactoryModule()]);
+  }
+  @override
+  void teardown() => CherryPick.closeRootScope();
+  @override
+  void run() {
+    scope.resolve<ServiceC>();
+  }
+}
+
+// === Named bindings: Multiple implementations ===
+class Impl1 {}
+class Impl2 {}
+class NamedModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<Object>().toProvide(() => Impl1()).withName('impl1');
+    bind<Object>().toProvide(() => Impl2()).withName('impl2');
+  }
+}
+
+class NamedResolveBenchmark extends BenchmarkBase {
+  NamedResolveBenchmark() : super('NamedResolve (by name)');
+  late Scope scope;
+  @override
+  void setup() {
+    scope = CherryPick.openRootScope();
+    scope.installModules([NamedModule()]);
+  }
+  @override
+  void teardown() => CherryPick.closeRootScope();
+  @override
+  void run() {
+    // Switch name for comparison
+    scope.resolve<Object>(named: 'impl2');
+  }
+}

benchmark_cherrypick/lib/scope_override_benchmark.dart

@@ -0,0 +1,46 @@
+// ignore: depend_on_referenced_packages
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:cherrypick/cherrypick.dart';
+
+class Shared {}
+class ParentImpl extends Shared {}
+class ChildImpl extends Shared {}
+
+class ParentModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<Shared>().toProvide(() => ParentImpl()).singleton();
+  }
+}
+
+class ChildOverrideModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<Shared>().toProvide(() => ChildImpl()).singleton();
+  }
+}
+
+class ScopeOverrideBenchmark extends BenchmarkBase {
+  ScopeOverrideBenchmark() : super('ScopeOverride (child overrides parent)');
+  late Scope parent;
+  late Scope child;
+  @override
+  void setup() {
+    CherryPick.disableGlobalCycleDetection();
+    CherryPick.disableGlobalCrossScopeCycleDetection();
+    parent = CherryPick.openRootScope();
+    parent.installModules([ParentModule()]);
+    child = parent.openSubScope('child');
+    child.installModules([ChildOverrideModule()]);
+  }
+  @override
+  void teardown() {
+    CherryPick.closeRootScope();
+  }
+  @override
+  void run() {
+    // Должен возвращать ChildImpl, а не ParentImpl
+    final resolved = child.resolve<Shared>();
+    assert(resolved is ChildImpl);
+  }
+}

benchmark_cherrypick/melos_benchmark_cherrypick.iml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/.dart_tool" />
+      <excludeFolder url="file://$MODULE_DIR$/.pub" />
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+    </content>
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="Dart SDK" level="project" />
+    <orderEntry type="library" name="Dart Packages" level="project" />
+  </component>
+</module>

benchmark_cherrypick/pubspec.lock

@@ -0,0 +1,68 @@
+# Generated by pub
+# See https://dart.dev/tools/pub/glossary#lockfile
+packages:
+  ansi_modifier:
+    dependency: transitive
+    description:
+      name: ansi_modifier
+      sha256: "4b97c241f345e49c929bd56d0198b567b7dfcca7ec8d4f798745c9ced998684c"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.1.4"
+  benchmark_harness:
+    dependency: "direct dev"
+    description:
+      name: benchmark_harness
+      sha256: "83f65107165883ba8623eb822daacb23dcf9f795c66841de758c9dd7c5a0cf28"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.3.1"
+  benchmark_runner:
+    dependency: "direct dev"
+    description:
+      name: benchmark_runner
+      sha256: "7de181228eb74cb34507ded2260fe88b3b71e0aacfe0dfa794df49edaf041ca3"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.0.4"
+  cherrypick:
+    dependency: "direct main"
+    description:
+      path: "../cherrypick"
+      relative: true
+    source: path
+    version: "3.0.0-dev.1"
+  exception_templates:
+    dependency: transitive
+    description:
+      name: exception_templates
+      sha256: "517f7c770da690073663f867ee2057ae2f4ffb28edae9da9faa624aa29ac76eb"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.1"
+  lazy_memo:
+    dependency: transitive
+    description:
+      name: lazy_memo
+      sha256: dcb30b4184a6d767e1d779d74ce784d752d38313b8fb4bad6b659ae7af4bb34d
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.2.3"
+  lints:
+    dependency: "direct dev"
+    description:
+      name: lints
+      sha256: c35bb79562d980e9a453fc715854e1ed39e24e7d0297a880ef54e17f9874a9d7
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.1.1"
+  meta:
+    dependency: transitive
+    description:
+      name: meta
+      sha256: "23f08335362185a5ea2ad3a4e597f1375e78bce8a040df5c600c8d3552ef2394"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.17.0"
+sdks:
+  dart: ">=3.6.0 <4.0.0"

benchmark_cherrypick/pubspec.yaml

@@ -0,0 +1,16 @@
+name: benchmark_cherrypick
+version: 0.1.0
+publish_to: none
+description: Benchmark for cherrypick core DI library
+
+environment:
+  sdk: '>=3.0.0 <4.0.0'
+
+dependencies:
+  cherrypick:
+    path: ../cherrypick
+
+dev_dependencies:
+  lints: ^5.0.0
+  benchmark_harness: ^2.2.2
+  benchmark_runner: ^0.0.2

cherrypick/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 3.0.0-dev.2
+
+> Note: This release has breaking changes.
+
+ - **FEAT**(binding): add deprecated proxy async methods for backward compatibility and highlight transition to modern API.
+ - **DOCS**: add quick guide for circular dependency detection to README.
+ - **DOCS**: add quick guide for circular dependency detection to README.
+ - **BREAKING** **FEAT**: implement comprehensive circular dependency detection system.
+ - **BREAKING** **FEAT**: implement comprehensive circular dependency detection system.
+
+## 3.0.0-dev.1
+
+ - **DOCS**: add quick guide for circular dependency detection to README.
+
 ## 3.0.0-dev.0
 
 > Note: This release has breaking changes.

cherrypick/README.md

@@ -8,7 +8,6 @@
 
 A **Binding** acts as a configuration for how to create or provide a particular dependency. Bindings support:
 
-
 - Direct instance assignment (`toInstance()`, `toInstanceAsync()`)
 - Lazy providers (sync/async functions)
 - Provider functions supporting dynamic parameters
@@ -239,6 +238,74 @@ class ApiClientImpl implements ApiClient {
 - [x] Null-safe Resolution (tryResolve/tryResolveAsync)
 - [x] Circular Dependency Detection (Local and Global)
 
+## Quick Guide: Circular Dependency Detection
+
+CherryPick can detect circular dependencies in your DI configuration, helping you avoid infinite loops and hard-to-debug errors.
+
+**How to use:**
+
+### 1. Enable Cycle Detection for Development
+
+**Local detection (within one scope):**
+```dart
+final scope = CherryPick.openSafeRootScope(); // Local detection enabled by default
+// or, for an existing scope:
+scope.enableCycleDetection();
+```
+
+**Global detection (across all scopes):**
+```dart
+CherryPick.enableGlobalCrossScopeCycleDetection();
+final rootScope = CherryPick.openGlobalSafeRootScope();
+```
+
+### 2. Error Example
+
+If you declare mutually dependent services:
+```dart
+class A { A(B b); }
+class B { B(A a); }
+
+scope.installModules([
+  Module((bind) {
+    bind<A>().to((s) => A(s.resolve<B>()));
+    bind<B>().to((s) => B(s.resolve<A>()));
+  }),
+]);
+
+scope.resolve<A>(); // Throws CircularDependencyException
+```
+
+### 3. Typical Usage Pattern
+
+- **Always enable detection** in debug and test environments for maximum safety.
+- **Disable detection** in production for performance (after code is tested).
+
+```dart
+import 'package:flutter/foundation.dart';
+
+void main() {
+  if (kDebugMode) {
+    CherryPick.enableGlobalCycleDetection();
+    CherryPick.enableGlobalCrossScopeCycleDetection();
+  }
+  runApp(MyApp());
+}
+```
+
+### 4. Handling and Debugging Errors
+
+On detection, `CircularDependencyException` is thrown with a readable dependency chain:
+```dart
+try {
+  scope.resolve<MyService>();
+} on CircularDependencyException catch (e) {
+  print('Dependency chain: ${e.dependencyChain}');
+}
+```
+
+**More details:** See [cycle_detection.en.md](doc/cycle_detection.en.md)
+
 ## Documentation
 
 - [Circular Dependency Detection (English)](doc/cycle_detection.en.md)
@@ -258,4 +325,4 @@ Licensed under the [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2
 
 ## Links
 
-- [GitHub Repository](https://github.com/pese-git/cherrypick)
+- [GitHub Repository](https://github.com/pese-git/cherrypick)

cherrypick/example/bin/main.dart

@@ -17,19 +17,28 @@ class FeatureModule extends Module {
   @override
   void builder(Scope currentScope) {
     // Using toProvideAsync for async initialization
-    bind<DataRepository>().withName("networkRepo").toProvideAsync(() async {
+    bind<DataRepository>()
+        .withName("networkRepo")
+        .toProvideWithParams((params) async {
+      print('REPO PARAMS: $params');
+
       final client = await Future.delayed(
-          Duration(milliseconds: 100),
-          () => currentScope.resolve<ApiClient>(
-              named: isMock ? "apiClientMock" : "apiClientImpl"));
+        Duration(milliseconds: 1000),
+        () => currentScope.resolve<ApiClient>(
+          named: isMock ? "apiClientMock" : "apiClientImpl",
+        ),
+      );
+
       return NetworkDataRepository(client);
     }).singleton();
 
     // Asynchronous initialization of DataBloc
-    bind<DataBloc>().toProvideAsync(
+    bind<DataBloc>().toProvide(
       () async {
         final repo = await currentScope.resolveAsync<DataRepository>(
-            named: "networkRepo");
+          named: "networkRepo",
+          params: 'Some params',
+        );
         return DataBloc(repo);
       },
     );
@@ -38,18 +47,19 @@ class FeatureModule extends Module {
 
 Future<void> main() async {
   try {
-    final scope = openRootScope().installModules([
-      AppModule(),
-    ]);
+  final scope = openRootScope().installModules([AppModule()]);
 
     final subScope = scope
         .openSubScope("featureScope")
         .installModules([FeatureModule(isMock: true)]);
 
-    // Asynchronous instance resolution
-    final dataBloc = await subScope.resolveAsync<DataBloc>();
-    dataBloc.data.listen((d) => print('Received data: $d'),
-        onError: (e) => print('Error: $e'), onDone: () => print('DONE'));
+  // Asynchronous instance resolution
+  final dataBloc = await subScope.resolveAsync<DataBloc>();
+  dataBloc.data.listen(
+    (d) => print('Received data: $d'),
+    onError: (e) => print('Error: $e'),
+    onDone: () => print('DONE'),
+  );
 
     await dataBloc.fetchData();
   } catch (e) {

cherrypick/lib/cherrypick.dart

@@ -13,6 +13,7 @@ library;
 // limitations under the License.
 //
 
+export 'package:cherrypick/src/binding_resolver.dart';
 export 'package:cherrypick/src/binding.dart';
 export 'package:cherrypick/src/cycle_detector.dart';
 export 'package:cherrypick/src/global_cycle_detector.dart';

cherrypick/lib/src/binding.dart

@@ -11,45 +11,21 @@
 // limitations under the License.
 //
 
-enum Mode { simple, instance, providerInstance, providerInstanceWithParams }
-
-typedef Provider<T> = T? Function();
-
-typedef ProviderWithParams<T> = T Function(dynamic params);
-
-typedef AsyncProvider<T> = Future<T> Function();
-
-typedef AsyncProviderWithParams<T> = Future<T> Function(dynamic params);
+import 'package:cherrypick/src/binding_resolver.dart';
 
 /// RU: Класс Binding<T> настраивает параметры экземпляра.
 /// ENG: The Binding<T> class configures the settings for the instance.
 ///
 class Binding<T> {
-  late Mode _mode;
   late Type _key;
-  late String _name;
-  T? _instance;
-  Future<T>? _instanceAsync;
-  Provider<T>? _provider;
-  ProviderWithParams<T>? _providerWithParams;
+  String? _name;
 
-  AsyncProvider<T>? asyncProvider;
-  AsyncProviderWithParams<T>? asyncProviderWithParams;
-
-  late bool _isSingleton = false;
-  late bool _isNamed = false;
+  BindingResolver<T>? _resolver;
 
   Binding() {
-    _mode = Mode.simple;
     _key = T;
   }
 
-  /// RU: Метод возвращает [Mode] экземпляра.
-  /// ENG: The method returns the [Mode] of the instance.
-  ///
-  /// return [Mode]
-  Mode get mode => _mode;
-
   /// RU: Метод возвращает тип экземпляра.
   /// ENG: The method returns the type of the instance.
   ///
@@ -60,19 +36,21 @@ class Binding<T> {
   /// ENG: The method returns the name of the instance.
   ///
   /// return [String]
-  String get name => _name;
-
-  /// RU: Метод проверяет сингелтон экземпляр или нет.
-  /// ENG: The method checks the singleton instance or not.
-  ///
-  /// return [bool]
-  bool get isSingleton => _isSingleton;
+  String? get name => _name;
 
   /// RU: Метод проверяет именован экземпляр или нет.
   /// ENG: The method checks whether the instance is named or not.
   ///
   /// return [bool]
-  bool get isNamed => _isNamed;
+  bool get isNamed => _name != null;
+
+  /// RU: Метод проверяет сингелтон экземпляр или нет.
+  /// ENG: The method checks the singleton instance or not.
+  ///
+  /// return [bool]
+  bool get isSingleton => _resolver?.isSingleton ?? false;
+
+  BindingResolver<T>? get resolver => _resolver;
 
   /// RU: Добавляет имя для экземляпя [value].
   /// ENG: Added name for instance [value].
@@ -80,7 +58,6 @@ class Binding<T> {
   /// return [Binding]
   Binding<T> withName(String name) {
     _name = name;
-    _isNamed = true;
     return this;
   }
 
@@ -88,21 +65,9 @@ class Binding<T> {
   /// ENG: Initialization instance [value].
   ///
   /// return [Binding]
-  Binding<T> toInstance(T value) {
-    _mode = Mode.instance;
-    _instance = value;
-    _isSingleton = true;
-    return this;
-  }
+  Binding<T> toInstance(Instance<T> value) {
+    _resolver = InstanceResolver<T>(value);
 
-  /// RU: Инициализация экземляпяра [value].
-  /// ENG: Initialization instance [value].
-  ///
-  /// return [Binding]
-  Binding<T> toInstanceAsync(Future<T> value) {
-    _mode = Mode.instance;
-    _instanceAsync = value;
-    _isSingleton = true;
     return this;
   }
 
@@ -111,18 +76,8 @@ class Binding<T> {
   ///
   /// return [Binding]
   Binding<T> toProvide(Provider<T> value) {
-    _mode = Mode.providerInstance;
-    _provider = value;
-    return this;
-  }
+    _resolver = ProviderResolver<T>((_) => value.call(), withParams: false);
 
-  /// RU: Инициализация экземляпяра  через провайдер [value].
-  /// ENG: Initialization instance via provider [value].
-  ///
-  /// return [Binding]
-  Binding<T> toProvideAsync(AsyncProvider<T> provider) {
-    _mode = Mode.providerInstance;
-    asyncProvider = provider;
     return this;
   }
 
@@ -131,19 +86,24 @@ class Binding<T> {
   ///
   /// return [Binding]
   Binding<T> toProvideWithParams(ProviderWithParams<T> value) {
-    _mode = Mode.providerInstanceWithParams;
-    _providerWithParams = value;
+    _resolver = ProviderResolver<T>(value, withParams: true);
+
     return this;
   }
 
-  /// RU: Инициализация экземляра через асинхронный провайдер [value] с динамическим параметром.
-  /// ENG: Initializes the instance via async provider [value] with a dynamic param.
-  ///
-  /// return [Binding]
-  Binding<T> toProvideAsyncWithParams(AsyncProviderWithParams<T> provider) {
-    _mode = Mode.providerInstanceWithParams;
-    asyncProviderWithParams = provider;
-    return this;
+  @Deprecated('Use toInstance instead of toInstanceAsync')
+  Binding<T> toInstanceAsync(Instance<T> value) {
+    return this.toInstance(value);
+  }
+
+  @Deprecated('Use toProvide instead of toProvideAsync')
+  Binding<T> toProvideAsync(Provider<T> value) {
+    return this.toProvide(value);
+  }
+
+  @Deprecated('Use toProvideWithParams instead of toProvideAsyncWithParams')
+  Binding<T> toProvideAsyncWithParams(ProviderWithParams<T> value) {
+    return this.toProvideWithParams(value);
   }
 
   /// RU: Инициализация экземляпяра  как сингелтон [value].
@@ -151,40 +111,16 @@ class Binding<T> {
   ///
   /// return [Binding]
   Binding<T> singleton() {
-    _isSingleton = true;
+    _resolver?.toSingleton();
+
     return this;
   }
 
-  /// RU: Поиск экземпляра.
-  /// ENG: Resolve instance.
-  ///
-  /// return [T]
-  T? get instance => _instance;
-
-  /// RU: Поиск экземпляра.
-  /// ENG: Resolve instance.
-  ///
-  /// return [T]
-  Future<T>? get instanceAsync => _instanceAsync;
-
-  /// RU: Поиск экземпляра.
-  /// ENG: Resolve instance.
-  ///
-  /// return [T]
-  T? get provider {
-    if (_isSingleton) {
-      _instance ??= _provider?.call();
-      return _instance;
-    }
-    return _provider?.call();
+  T? resolveSync([dynamic params]) {
+    return resolver?.resolveSync(params);
   }
 
-  /// RU: Поиск экземпляра с параметром.
-  ///
-  /// ENG: Resolve instance with [params].
-  ///
-  /// return [T]
-  T? providerWithParams(dynamic params) {
-    return _providerWithParams?.call(params);
+  Future<T>? resolveAsync([dynamic params]) {
+    return resolver?.resolveAsync(params);
   }
 }

cherrypick/lib/src/binding_resolver.dart

@@ -0,0 +1,129 @@
+import 'dart:async';
+
+typedef Instance<T> = FutureOr<T>;
+
+/// RU: Синхронный или асинхронный провайдер без параметров, возвращающий [T] или [Future<T>].
+/// ENG: Synchronous or asynchronous provider without parameters, returning [T] or [Future<T>].
+typedef Provider<T> = FutureOr<T> Function();
+
+/// RU: Провайдер с динамическим параметром, возвращающий [T] или [Future<T>] в зависимости от реализации.
+/// ENG: Provider with dynamic parameter, returning [T] or [Future<T>] depending on implementation.
+typedef ProviderWithParams<T> = FutureOr<T> Function(dynamic);
+
+/// RU: Абстрактный интерфейс для классов, которые разрешают зависимости типа [T].
+/// ENG: Abstract interface for classes that resolve dependencies of type [T].
+abstract class BindingResolver<T> {
+  /// RU: Синхронное разрешение зависимости с параметром [params].
+  /// ENG: Synchronous resolution of the dependency with [params].
+  T? resolveSync([dynamic params]);
+
+  /// RU: Асинхронное разрешение зависимости с параметром [params].
+  /// ENG: Asynchronous resolution of the dependency with [params].
+  Future<T>? resolveAsync([dynamic params]);
+
+  /// RU: Помечает текущий резолвер как синглтон — результат будет закеширован.
+  /// ENG: Marks this resolver as singleton — result will be cached.
+  void toSingleton();
+
+  bool get isSingleton;
+}
+
+/// RU: Резолвер, оборачивающий конкретный экземпляр [T] (или Future<T>), без вызова провайдера.
+/// ENG: Resolver that wraps a concrete instance of [T] (or Future<T>), without provider invocation.
+class InstanceResolver<T> implements BindingResolver<T> {
+  final Instance<T> _instance;
+
+  /// RU: Создаёт резолвер, оборачивающий значение [instance].
+  /// ENG: Creates a resolver that wraps the given [instance].
+  InstanceResolver(this._instance);
+
+  @override
+  T resolveSync([_]) {
+    if (_instance is T) return _instance;
+    throw StateError(
+      'Instance $_instance is Future; '
+      'use resolveAsync() instead',
+    );
+  }
+
+  @override
+  Future<T> resolveAsync([_]) {
+    if (_instance is Future<T>) return _instance;
+
+    return Future.value(_instance);
+  }
+
+  @override
+  void toSingleton() {}
+
+  @override
+  bool get isSingleton => true;
+}
+
+/// RU: Резолвер, оборачивающий провайдер, с возможностью синглтон-кеширования.
+/// ENG: Resolver that wraps a provider, with optional singleton caching.
+class ProviderResolver<T> implements BindingResolver<T> {
+  final ProviderWithParams<T> _provider;
+  final bool _withParams;
+
+  FutureOr<T>? _cache;
+  bool _singleton = false;
+
+  /// RU: Создаёт резолвер из произвольной функции [raw], поддерживающей ноль или один параметр.
+  /// ENG: Creates a resolver from arbitrary function [raw], supporting zero or one parameter.
+  ProviderResolver(
+    ProviderWithParams<T> provider, {
+    required bool withParams,
+  })  : _provider = provider,
+        _withParams = withParams;
+
+  @override
+  T resolveSync([dynamic params]) {
+    _checkParams(params);
+
+    final result = _cache ?? _provider(params);
+
+    if (result is T) {
+      if (_singleton) {
+        _cache ??= result;
+      }
+      return result;
+    }
+
+    throw StateError(
+      'Provider [$_provider] return Future<$T>. Use resolveAsync() instead.',
+    );
+  }
+
+  @override
+  Future<T> resolveAsync([dynamic params]) {
+    _checkParams(params);
+
+    final result = _cache ?? _provider(params);
+    final target = result is Future<T> ? result : Future<T>.value(result);
+
+    if (_singleton) {
+      _cache ??= target;
+    }
+
+    return target;
+  }
+
+  @override
+  void toSingleton() {
+    _singleton = true;
+  }
+
+  @override
+  bool get isSingleton => _singleton;
+
+  /// RU: Проверяет, был ли передан параметр, если провайдер требует его.
+  /// ENG: Checks if parameter is passed when the provider expects it.
+  void _checkParams(dynamic params) {
+    if (_withParams && params == null) {
+      throw StateError(
+        '[$T] Params is null. Maybe you forgot to pass it?',
+      );
+    }
+  }
+}

cherrypick/lib/src/scope.dart

@@ -13,9 +13,9 @@
 import 'dart:collection';
 import 'dart:math';
 
-import 'package:cherrypick/src/binding.dart';
 import 'package:cherrypick/src/cycle_detector.dart';
 import 'package:cherrypick/src/global_cycle_detector.dart';
+import 'package:cherrypick/src/binding_resolver.dart';
 import 'package:cherrypick/src/module.dart';
 
 Scope openRootScope() => Scope(null);
@@ -176,33 +176,12 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
   /// RU: Внутренний метод для разрешения зависимостей без проверки циклических зависимостей.
   /// ENG: Internal method for dependency resolution without circular dependency checking.
   T? _tryResolveInternal<T>({String? named, dynamic params}) {
-    // 1 Поиск зависимости по всем модулям текущего скоупа
-    if (_modulesList.isNotEmpty) {
-      for (var module in _modulesList) {
-        for (var binding in module.bindingSet) {
-          if (binding.key == T &&
-              ((!binding.isNamed && named == null) ||
-                  (binding.isNamed && named == binding.name))) {
-            switch (binding.mode) {
-              case Mode.instance:
-                return binding.instance;
-              case Mode.providerInstance:
-                return binding.provider;
-              case Mode.providerInstanceWithParams:
-                if (params == null) {
-                  throw StateError('Param is null. Maybe you forget pass it');
-                }
-                return binding.providerWithParams(params);
-              default:
-                return null;
-            }
-          }
-        }
-      }
-    }
+    final resolver = _findBindingResolver<T>(named);
 
-    // 2 Поиск зависимостей в родительском скоупе
-    return _parentScope?._tryResolveInternal(named: named, params: params);
+    // 1 Поиск зависимости по всем модулям текущего скоупа
+    return resolver?.resolveSync(params) ??
+        // 2 Поиск зависимостей в родительском скоупе
+        _parentScope?.tryResolve(named: named, params: params);
   }
 
   /// RU: Асинхронно возвращает найденную зависимость, определенную параметром типа [T].
@@ -266,30 +245,25 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
   /// RU: Внутренний метод для асинхронного разрешения зависимостей без проверки циклических зависимостей.
   /// ENG: Internal method for async dependency resolution without circular dependency checking.
   Future<T?> _tryResolveAsyncInternal<T>({String? named, dynamic params}) async {
-    if (_modulesList.isNotEmpty) {
-      for (var module in _modulesList) {
-        for (var binding in module.bindingSet) {
-          if (binding.key == T &&
-              ((!binding.isNamed && named == null) ||
-                  (binding.isNamed && named == binding.name))) {
-            if (binding.instanceAsync != null) {
-              return await binding.instanceAsync;
-            }
+    final resolver = _findBindingResolver<T>(named);
 
-            if (binding.asyncProvider != null) {
-              return await binding.asyncProvider?.call();
-            }
+    // 1 Поиск зависимости по всем модулям текущего скоупа
+    return resolver?.resolveAsync(params) ??
+        // 2 Поиск зависимостей в родительском скоупе
+        _parentScope?.tryResolveAsync(named: named, params: params);
+  }
 
-            if (binding.asyncProviderWithParams != null) {
-              if (params == null) {
-                throw StateError('Param is null. Maybe you forget pass it');
-              }
-              return await binding.asyncProviderWithParams!(params);
-            }
-          }
+  BindingResolver<T>? _findBindingResolver<T>(String? named) {
+    for (var module in _modulesList) {
+      for (var binding in module.bindingSet) {
+        if (binding.key == T &&
+            ((!binding.isNamed && named == null) ||
+                (binding.isNamed && named == binding.name))) {
+          return binding.resolver as BindingResolver<T>?;
         }
       }
     }
-    return _parentScope?._tryResolveAsyncInternal(named: named, params: params);
+
+    return null;
   }
 }

cherrypick/pubspec.yaml

@@ -1,6 +1,6 @@
 name: cherrypick
 description: Cherrypick is a small dependency injection (DI) library for dart/flutter projects.
-version: 3.0.0-dev.0
+version: 3.0.0-dev.2
 homepage: https://pese-git.github.io/cherrypick-site/
 documentation: https://github.com/pese-git/cherrypick/wiki
 repository: https://github.com/pese-git/cherrypick

cherrypick/test/src/binding_test.dart

@@ -1,4 +1,4 @@
-import 'package:cherrypick/src/binding.dart';
+import 'package:cherrypick/cherrypick.dart';
 import 'package:test/test.dart';
 
 void main() {
@@ -7,12 +7,12 @@ void main() {
     group('Without name', () {
       test('Returns null by default', () {
         final binding = Binding<int>();
-        expect(binding.instance, null);
+        expect(binding.resolver, null);
       });
 
       test('Sets mode to instance', () {
         final binding = Binding<int>().toInstance(5);
-        expect(binding.mode, Mode.instance);
+        expect(binding.resolver, isA<InstanceResolver<int>>());
       });
 
       test('isSingleton is true', () {
@@ -22,19 +22,19 @@ void main() {
 
       test('Stores value', () {
         final binding = Binding<int>().toInstance(5);
-        expect(binding.instance, 5);
+        expect(binding.resolver?.resolveSync(), 5);
       });
     });
 
     group('With name', () {
       test('Returns null by default', () {
         final binding = Binding<int>().withName('n');
-        expect(binding.instance, null);
+        expect(binding.resolver, null);
       });
 
       test('Sets mode to instance', () {
         final binding = Binding<int>().withName('n').toInstance(5);
-        expect(binding.mode, Mode.instance);
+        expect(binding.resolver, isA<InstanceResolver<int>>());
       });
 
       test('Sets key', () {
@@ -49,7 +49,7 @@ void main() {
 
       test('Stores value', () {
         final binding = Binding<int>().withName('n').toInstance(5);
-        expect(binding.instance, 5);
+        expect(binding.resolver?.resolveSync(), 5);
       });
 
       test('Sets name', () {
@@ -60,45 +60,39 @@ void main() {
 
     test('Multiple toInstance calls change value', () {
       final binding = Binding<int>().toInstance(1).toInstance(2);
-      expect(binding.instance, 2);
+      expect(binding.resolver?.resolveSync(), 2);
     });
   });
 
   // --- Instance binding (asynchronous) ---
   group('Async Instance Binding (toInstanceAsync)', () {
     test('Resolves instanceAsync with expected value', () async {
-      final binding = Binding<int>().toInstanceAsync(Future.value(42));
-      expect(await binding.instanceAsync, 42);
-    });
-
-    test('Does not affect instance', () {
-      final binding = Binding<int>().toInstanceAsync(Future.value(5));
-      expect(binding.instance, null);
+      final binding = Binding<int>().toInstance(Future.value(42));
+      expect(await binding.resolveAsync(), 42);
     });
 
     test('Sets mode to instance', () {
-      final binding = Binding<int>().toInstanceAsync(Future.value(5));
-      expect(binding.mode, Mode.instance);
+      final binding = Binding<int>().toInstance(Future.value(5));
+      expect(binding.resolver, isA<InstanceResolver<int>>());
     });
 
     test('isSingleton is true after toInstanceAsync', () {
-      final binding = Binding<int>().toInstanceAsync(Future.value(5));
+      final binding = Binding<int>().toInstance(Future.value(5));
       expect(binding.isSingleton, isTrue);
     });
 
     test('Composes with withName', () async {
-      final binding = Binding<int>()
-          .withName('asyncValue')
-          .toInstanceAsync(Future.value(7));
+      final binding =
+          Binding<int>().withName('asyncValue').toInstance(Future.value(7));
       expect(binding.isNamed, isTrue);
       expect(binding.name, 'asyncValue');
-      expect(await binding.instanceAsync, 7);
+      expect(await binding.resolveAsync(), 7);
     });
 
     test('Keeps value after multiple awaits', () async {
-      final binding = Binding<int>().toInstanceAsync(Future.value(123));
-      final result1 = await binding.instanceAsync;
-      final result2 = await binding.instanceAsync;
+      final binding = Binding<int>().toInstance(Future.value(123));
+      final result1 = await binding.resolveAsync();
+      final result2 = await binding.resolveAsync();
       expect(result1, equals(result2));
     });
   });
@@ -108,12 +102,12 @@ void main() {
     group('Without name', () {
       test('Returns null by default', () {
         final binding = Binding<int>();
-        expect(binding.provider, null);
+        expect(binding.resolver, null);
       });
 
       test('Sets mode to providerInstance', () {
         final binding = Binding<int>().toProvide(() => 5);
-        expect(binding.mode, Mode.providerInstance);
+        expect(binding.resolver, isA<ProviderResolver<int>>());
       });
 
       test('isSingleton is false by default', () {
@@ -123,19 +117,19 @@ void main() {
 
       test('Returns provided value', () {
         final binding = Binding<int>().toProvide(() => 5);
-        expect(binding.provider, 5);
+        expect(binding.resolveSync(), 5);
       });
     });
 
     group('With name', () {
       test('Returns null by default', () {
         final binding = Binding<int>().withName('n');
-        expect(binding.provider, null);
+        expect(binding.resolver, null);
       });
 
       test('Sets mode to providerInstance', () {
         final binding = Binding<int>().withName('n').toProvide(() => 5);
-        expect(binding.mode, Mode.providerInstance);
+        expect(binding.resolver, isA<ProviderResolver<int>>());
       });
 
       test('Sets key', () {
@@ -150,7 +144,7 @@ void main() {
 
       test('Returns provided value', () {
         final binding = Binding<int>().withName('n').toProvide(() => 5);
-        expect(binding.provider, 5);
+        expect(binding.resolveSync(), 5);
       });
 
       test('Sets name', () {
@@ -163,14 +157,14 @@ void main() {
   // --- Async provider binding ---
   group('Async Provider Binding', () {
     test('Resolves asyncProvider value', () async {
-      final binding = Binding<int>().toProvideAsync(() async => 5);
-      expect(await binding.asyncProvider?.call(), 5);
+      final binding = Binding<int>().toProvide(() async => 5);
+      expect(await binding.resolveAsync(), 5);
     });
 
     test('Resolves asyncProviderWithParams value', () async {
       final binding = Binding<int>()
-          .toProvideAsyncWithParams((param) async => 5 + (param as int));
-      expect(await binding.asyncProviderWithParams?.call(3), 8);
+          .toProvideWithParams((param) async => 5 + (param as int));
+      expect(await binding.resolveAsync(3), 8);
     });
   });
 
@@ -179,12 +173,7 @@ void main() {
     group('Without name', () {
       test('Returns null if no provider set', () {
         final binding = Binding<int>().singleton();
-        expect(binding.provider, null);
-      });
-
-      test('Sets mode to providerInstance', () {
-        final binding = Binding<int>().toProvide(() => 5).singleton();
-        expect(binding.mode, Mode.providerInstance);
+        expect(binding.resolver, null);
       });
 
       test('isSingleton is true', () {
@@ -194,7 +183,7 @@ void main() {
 
       test('Returns singleton value', () {
         final binding = Binding<int>().toProvide(() => 5).singleton();
-        expect(binding.provider, 5);
+        expect(binding.resolveSync(), 5);
       });
 
       test('Returns same value each call and provider only called once', () {
@@ -204,8 +193,8 @@ void main() {
           return counter;
         }).singleton();
 
-        final first = binding.provider;
-        final second = binding.provider;
+        final first = binding.resolveSync();
+        final second = binding.resolveSync();
         expect(first, equals(second));
         expect(counter, 1);
       });
@@ -214,13 +203,7 @@ void main() {
     group('With name', () {
       test('Returns null if no provider set', () {
         final binding = Binding<int>().withName('n').singleton();
-        expect(binding.provider, null);
-      });
-
-      test('Sets mode to providerInstance', () {
-        final binding =
-            Binding<int>().withName('n').toProvide(() => 5).singleton();
-        expect(binding.mode, Mode.providerInstance);
+        expect(binding.resolver, null);
       });
 
       test('Sets key', () {
@@ -238,7 +221,7 @@ void main() {
       test('Returns singleton value', () {
         final binding =
             Binding<int>().withName('n').toProvide(() => 5).singleton();
-        expect(binding.provider, 5);
+        expect(binding.resolveSync(), 5);
       });
 
       test('Sets name', () {
@@ -247,12 +230,6 @@ void main() {
         expect(binding.name, 'n');
       });
     });
-
-    test('Chained withName and singleton preserves mode', () {
-      final binding =
-          Binding<int>().toProvide(() => 3).withName("named").singleton();
-      expect(binding.mode, Mode.providerInstance);
-    });
   });
 
   // --- WithName / Named binding, isNamed, edge-cases ---
@@ -265,7 +242,7 @@ void main() {
 
     test('providerWithParams returns null if not set', () {
       final binding = Binding<int>();
-      expect(binding.providerWithParams(123), null);
+      expect(binding.resolveSync(123), null);
     });
   });
 }

cherrypick/test/src/cycle_detector_test.dart

@@ -200,11 +200,13 @@ class AsyncServiceB {
 class AsyncCircularModule extends Module {
   @override
   void builder(Scope currentScope) {
+    // ignore: deprecated_member_use_from_same_package
     bind<AsyncServiceA>().toProvideAsync(() async {
       final serviceB = await currentScope.resolveAsync<AsyncServiceB>();
       return AsyncServiceA(serviceB);
     });
     
+    // ignore: deprecated_member_use_from_same_package
     bind<AsyncServiceB>().toProvideAsync(() async {
       final serviceA = await currentScope.resolveAsync<AsyncServiceA>();
       return AsyncServiceB(serviceA);

cherrypick/test/src/scope_test.dart

@@ -127,7 +127,7 @@ void main() {
       final scope = Scope(null)
         ..installModules([
           _InlineModule((m, s) {
-            m.bind<String>().toInstanceAsync(Future.value('async value'));
+            m.bind<String>().toInstance(Future.value('async value'));
           }),
         ]);
       expect(await scope.resolveAsync<String>(), "async value");
@@ -137,7 +137,7 @@ void main() {
       final scope = Scope(null)
         ..installModules([
           _InlineModule((m, s) {
-            m.bind<int>().toProvideAsync(() async => 7);
+            m.bind<int>().toProvide(() async => 7);
           }),
         ]);
       expect(await scope.resolveAsync<int>(), 7);
@@ -147,7 +147,7 @@ void main() {
       final scope = Scope(null)
         ..installModules([
           _InlineModule((m, s) {
-            m.bind<int>().toProvideAsyncWithParams((x) async => (x as int) * 3);
+            m.bind<int>().toProvideWithParams((x) async => (x as int) * 3);
           }),
         ]);
       expect(await scope.resolveAsync<int>(params: 2), 6);

cherrypick_flutter/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.1.3-dev.2
+
+ - Update a dependency to the latest release.
+
+## 1.1.3-dev.1
+
+ - Update a dependency to the latest release.
+
 ## 1.1.3-dev.0
 
  - **FIX**: update deps.

cherrypick_flutter/pubspec.yaml

@@ -1,6 +1,6 @@
 name: cherrypick_flutter
 description: "Flutter library that allows access to the root scope through the context using `CherryPickProvider`."
-version: 1.1.3-dev.0
+version: 1.1.3-dev.2
 homepage: https://pese-git.github.io/cherrypick-site/
 documentation: https://github.com/pese-git/cherrypick/wiki
 repository: https://github.com/pese-git/cherrypick
@@ -13,7 +13,7 @@ environment:
 dependencies:
   flutter:
     sdk: flutter
-  cherrypick: ^3.0.0-dev.0
+  cherrypick: ^3.0.0-dev.2
 
 dev_dependencies:
   flutter_test:

examples/client_app/pubspec.lock

@@ -127,7 +127,7 @@ packages:
       path: "../../cherrypick"
       relative: true
     source: path
-    version: "2.2.0"
+    version: "3.0.0-dev.1"
   cherrypick_annotations:
     dependency: "direct main"
     description:
@@ -141,7 +141,7 @@ packages:
       path: "../../cherrypick_flutter"
       relative: true
     source: path
-    version: "1.1.2"
+    version: "1.1.3-dev.1"
   cherrypick_generator:
     dependency: "direct dev"
     description:

examples/postly/pubspec.lock

@@ -151,7 +151,7 @@ packages:
       path: "../../cherrypick"
       relative: true
     source: path
-    version: "2.2.0"
+    version: "3.0.0-dev.1"
   cherrypick_annotations:
     dependency: "direct main"
     description:

melos.yaml

@@ -3,6 +3,7 @@ name: cherrypick_workspace
 sdkPath: .fvm/flutter_sdk
 
 packages:
+  - benchmark_cherrypick
   - cherrypick
   - cherrypick_flutter
   - cherrypick_annotations