chore(release): publish packages

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

CHANGELOG.md

@@ -3,6 +3,158 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2025-08-07
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.5`](#cherrypick---v300-dev5)
+ - [`cherrypick_flutter` - `v1.1.3-dev.5`](#cherrypick_flutter---v113-dev5)
+
+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.5`
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.5`
+
+ - **REFACTOR**(scope): simplify _findBindingResolver<T> with one-liner and optional chaining.
+ - **PERF**(scope): speed up dependency lookup with Map-based binding resolver index.
+ - **DOCS**(perf): clarify Map-based resolver optimization applies since v3.0.0 in all docs.
+ - **DOCS**: update EN/RU quick start and tutorial with Fast Map-based lookup section; clarify performance benefit in README.
+
+
+## 2025-08-07
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.4`](#cherrypick---v300-dev4)
+ - [`cherrypick_flutter` - `v1.1.3-dev.4`](#cherrypick_flutter---v113-dev4)
+
+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.4`
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.4`
+
+ - **REFACTOR**(scope): simplify _findBindingResolver<T> with one-liner and optional chaining.
+ - **PERF**(scope): speed up dependency lookup with Map-based binding resolver index.
+ - **DOCS**(perf): clarify Map-based resolver optimization applies since v3.0.0 in all docs.
+ - **DOCS**: update EN/RU quick start and tutorial with Fast Map-based lookup section; clarify performance benefit in README.
+
+
+## 2025-08-07
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.3`](#cherrypick---v300-dev3)
+ - [`cherrypick_flutter` - `v1.1.3-dev.3`](#cherrypick_flutter---v113-dev3)
+
+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.3`
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.3`
+
+ - **REFACTOR**(scope): simplify _findBindingResolver<T> with one-liner and optional chaining.
+ - **PERF**(scope): speed up dependency lookup with Map-based binding resolver index.
+ - **DOCS**(perf): clarify Map-based resolver optimization applies since v3.0.0 in all docs.
+ - **DOCS**: update EN/RU quick start and tutorial with Fast Map-based lookup section; clarify performance benefit in README.
+
+
+## 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_di/README.md

@@ -0,0 +1,275 @@
+# benchmark_di
+
+_Benchmark suite for cherrypick DI container, get_it, and other DI solutions._
+
+## Overview
+
+benchmark_di is a flexible benchmarking suite to compare DI containers (like cherrypick and get_it) on synthetic, deep, and real-world dependency scenarios – chains, factories, async, named, override, etc.
+
+**Features:**
+- Universal registration layer and modular scenario setup (works with any DI)
+- Built-in support for [cherrypick](https://github.com/) and [get_it](https://pub.dev/packages/get_it)
+- Clean CLI for matrix runs and output formats (Markdown, CSV, JSON, pretty)
+- Reports metrics: timings, memory (RSS, peak), statistical spreads, and more
+- Extendable via your own DIAdapter or benchmark scenarios
+
+---
+
+## Benchmark Scenarios
+
+- **registerSingleton**: Simple singleton registration/resolution
+- **chainSingleton**: Resolution of long singleton chains (A→B→C...)
+- **chainFactory**: Chain resolution via factories (new instances each time)
+- **asyncChain**: Async chain (with async providers)
+- **named**: Named/qualified resolution (e.g. from multiple implementations)
+- **override**: Resolution and override in subScopes/child adapters
+
+---
+
+## Supported DI
+
+- **cherrypick** (default)
+- **get_it**
+- Easy to add your own DI by creating a DIAdapter
+
+Switch DI with the CLI option: `--di`
+
+---
+
+## How to Run
+
+1. **Install dependencies:**
+   ```shell
+   dart pub get
+   ```
+
+2. **Run all benchmarks (default: all scenarios, 2 warmup, 2 repeats):**
+   ```shell
+   dart run bin/main.dart --benchmark=all --format=markdown
+   ```
+
+3. **For get_it:**
+   ```shell
+   dart run bin/main.dart --di=getit --benchmark=all --format=markdown
+   ```
+
+4. **Show all CLI options:**
+   ```shell
+   dart run bin/main.dart --help
+   ```
+
+### CLI Parameters
+
+- `--di` — DI implementation: `cherrypick` (default) or `getit`
+- `--benchmark, -b` — Scenario: `registerSingleton`, `chainSingleton`, `chainFactory`, `asyncChain`, `named`, `override`, `all`
+- `--chainCount, -c` — Number of parallel chains (e.g. `10,100`)
+- `--nestingDepth, -d` — Chain depth (e.g. `5,10`)
+- `--repeat, -r` — Measurement repeats (default: 2)
+- `--warmup, -w` — Warmup runs (default: 1)
+- `--format, -f` — Output: `pretty`, `csv`, `json`, `markdown`
+- `--help, -h` — Usage
+
+### Run Examples
+
+- **All benchmarks for cherrypick:**
+  ```shell
+  dart run bin/main.dart --di=cherrypick --benchmark=all --format=markdown
+  ```
+
+- **For get_it (all scenarios):**
+  ```shell
+  dart run bin/main.dart --di=getit --benchmark=all --format=markdown
+  ```
+
+- **Specify chains/depth matrix:**
+  ```shell
+  dart run bin/main.dart --benchmark=chainSingleton --chainCount=10,100 --nestingDepth=5,10 --repeat=3 --format=csv
+  ```
+
+---
+
+## Universal DI registration: Adapter-centric approach
+
+Starting from vX.Y.Z, all DI registration scenarios and logic are encapsulated in the adapter itself via the `universalRegistration` method.
+
+### How to use (in Dart code):
+
+```dart
+final di = CherrypickDIAdapter(); // or GetItAdapter(), RiverpodAdapter(), etc
+
+di.setupDependencies(
+  di.universalRegistration(
+    scenario: UniversalScenario.chain,
+    chainCount: 10,
+    nestingDepth: 5,
+    bindingMode: UniversalBindingMode.singletonStrategy,
+  ),
+);
+```
+- There is **no more need to use any global function or switch**: each adapter provides its own type-safe implementation.
+
+### How to add a new scenario or DI:
+- Implement `universalRegistration<S extends Enum>(...)` in your adapter
+- Use your own Enum if you want adapter-specific scenarios!
+- Benchmarks and CLI become automatically extensible for custom DI and scenarios.
+
+### CLI usage (runs all universal scenarios for Cherrypick, GetIt, Riverpod):
+
+```
+dart run bin/main.dart --di=cherrypick --benchmark=all
+dart run bin/main.dart --di=getit --benchmark=all
+dart run bin/main.dart --di=riverpod --benchmark=all
+```
+
+See the `benchmark_di/lib/di_adapters/` folder for ready-to-use adapters.
+
+---
+## Advantages
+
+- **Type-safe:** Zero dynamic/object usage in DI flows.
+- **Extensible:** New scenarios are just new Enum values and a method extension.
+- **No global registration logic:** All DI-related logic is where it belongs: in the adapter.
+
+=======
+## How to Add Your Own DI
+
+1. Implement a class extending `DIAdapter` (`lib/di_adapters/your_adapter.dart`)
+2. Implement the `universalRegistration<S extends Enum>(...)` method directly in your adapter for type-safe and scenario-specific registration
+3. Register your adapter in CLI (see `cli/benchmark_cli.dart`)
+4. No global function needed — all logic is within the adapter!
+
+---
+## Universal DI registration: Adapter-centric approach
+
+Starting from vX.Y.Z, all DI registration scenarios and logic are encapsulated in the adapter itself via the `universalRegistration` method.
+
+### How to use (in Dart code):
+
+```dart
+final di = CherrypickDIAdapter(); // or GetItAdapter(), RiverpodAdapter(), etc
+
+di.setupDependencies(
+  di.universalRegistration(
+    scenario: UniversalScenario.chain,
+    chainCount: 10,
+    nestingDepth: 5,
+    bindingMode: UniversalBindingMode.singletonStrategy,
+  ),
+);
+```
+- There is **no more need to use any global function or switch**: each adapter provides its own type-safe implementation.
+
+### How to add a new scenario or DI:
+- Implement `universalRegistration<S extends Enum>(...)` in your adapter
+- Use your own Enum if you want adapter-specific scenarios!
+- Benchmarks and CLI become automatically extensible for custom DI and scenarios.
+
+### CLI usage (runs all universal scenarios for Cherrypick, GetIt, Riverpod):
+
+```
+dart run bin/main.dart --di=cherrypick --benchmark=all
+dart run bin/main.dart --di=getit --benchmark=all
+dart run bin/main.dart --di=riverpod --benchmark=all
+```
+
+See the `benchmark_di/lib/di_adapters/` folder for ready-to-use adapters.
+
+## Advantages
+
+- **Type-safe:** Zero dynamic/object usage in DI flows.
+- **Extensible:** New scenarios are just new Enum values and a method extension.
+- **No global registration logic:** All DI-related logic is where it belongs: in the adapter.
+
+---
+
+## Architecture
+
+```mermaid
+classDiagram
+    class BenchmarkCliRunner {
+        +run(args)
+    }
+    class UniversalChainBenchmark~TContainer~ {
+        +setup()
+        +run()
+        +teardown()
+    }
+    class UniversalChainAsyncBenchmark~TContainer~ {
+        +setup()
+        +run()
+        +teardown()
+    }
+    class DIAdapter~TContainer~ {
+        <<interface>>
+        +setupDependencies(cb)
+        +resolve~T~(named)
+        +resolveAsync~T~(named)
+        +teardown()
+        +openSubScope(name)
+        +waitForAsyncReady()
+        +universalRegistration<S extends Enum>(...)
+    }
+    class CherrypickDIAdapter
+    class GetItAdapter
+    class RiverpodAdapter
+    class UniversalChainModule {
+        +builder(scope)
+        +chainCount
+        +nestingDepth
+        +bindingMode
+        +scenario
+    }
+    class UniversalService {
+        <<interface>>
+        +value
+        +dependency
+    }
+    class UniversalServiceImpl {
+        +UniversalServiceImpl(value, dependency)
+    }
+    class Scope
+    class UniversalScenario
+    class UniversalBindingMode
+
+    %% Relationships
+
+    BenchmarkCliRunner --> UniversalChainBenchmark
+    BenchmarkCliRunner --> UniversalChainAsyncBenchmark
+
+    UniversalChainBenchmark *-- DIAdapter
+    UniversalChainAsyncBenchmark *-- DIAdapter
+
+    DIAdapter <|.. CherrypickDIAdapter
+    DIAdapter <|.. GetItAdapter
+    DIAdapter <|.. RiverpodAdapter
+
+    CherrypickDIAdapter ..> Scope
+    GetItAdapter ..> GetIt: "uses GetIt"
+    RiverpodAdapter ..> Map~String, ProviderBase~: "uses Provider registry"
+
+    DIAdapter o--> UniversalChainModule : setupDependencies
+
+    UniversalChainModule ..> UniversalScenario
+    UniversalChainModule ..> UniversalBindingMode
+
+    UniversalChainModule o-- UniversalServiceImpl : creates
+    UniversalService <|.. UniversalServiceImpl
+    UniversalServiceImpl --> UniversalService : dependency
+
+    %% 
+    %% Each concrete adapter implements universalRegistration<S extends Enum>
+    %% You can add new scenario enums for custom adapters
+    %% Extensibility is achieved via adapter logic, not global functions
+```
+
+---
+
+## Metrics
+
+Always collected:
+- **Timings** (microseconds): mean, median, stddev, min, max
+- **Memory**: RSS difference, peak RSS
+
+## License
+
+MIT

benchmark_di/README.ru.md

@@ -0,0 +1,226 @@
+# benchmark_di
+
+_Бенчмаркинговый набор для cherrypick, get_it и других DI-контейнеров._
+
+## Общее описание
+
+benchmark_di — это современный фреймворк для измерения производительности DI-контейнеров (как cherrypick, так и get_it) на синтетических, сложных и реальных сценариях: цепочки зависимостей, factory, async, именованные биндинги, override и пр.
+
+**Возможности:**
+- Универсальный слой регистрации сценариев (работает с любым DI)
+- Готовая поддержка [cherrypick](https://github.com/) и [get_it](https://pub.dev/packages/get_it)
+- Удобный CLI для запусков по матрице значений параметров и различных форматов вывода (Markdown, CSV, JSON, pretty)
+- Сбор и вывод метрик: время, память (RSS, peak), статистика (среднее, медиана, stddev, min/max)
+- Легко расширять — создавайте свой DIAdapter и новые сценарии
+
+---
+
+## Сценарии бенчмарков
+
+- **registerSingleton**: Регистрация и резолвинг singleton
+- **chainSingleton**: Разрешение длинных singleton-цепочек (A→B→C…)
+- **chainFactory**: То же, но с factory (каждый раз — новый объект)
+- **asyncChain**: Асинхронная цепочка (async factory/provider)
+- **named**: Разрешение по имени (например, из нескольких реализаций)
+- **override**: Переопределение зависимостей в subScope
+
+---
+
+## Поддерживаемые DI-контейнеры
+
+- **cherrypick** (по умолчанию)
+- **get_it**
+- Легко добавить свой DI через DIAdapter
+
+Меняется одной CLI-опцией: `--di`
+
+---
+
+## Как запустить
+
+1. **Установить зависимости:**
+   ```shell
+   dart pub get
+   ```
+
+2. **Запустить все бенчмарки (по умолчанию: все сценарии, 2 прогрева, 2 замера):**
+   ```shell
+   dart run bin/main.dart --benchmark=all --format=markdown
+   ```
+
+3. **Для get_it:**
+   ```shell
+   dart run bin/main.dart --di=getit --benchmark=all --format=markdown
+   ```
+
+4. **Показать все опции CLI:**
+   ```shell
+   dart run bin/main.dart --help
+   ```
+
+### Параметры CLI
+
+- `--di` — Какой DI использовать: `cherrypick` (по умолчанию) или `getit`
+- `--benchmark, -b` — Сценарий: `registerSingleton`, `chainSingleton`, `chainFactory`, `asyncChain`, `named`, `override`, `all`
+- `--chainCount, -c` — Сколько параллельных цепочек (например, `10,100`)
+- `--nestingDepth, -d` — Глубина цепочки (например, `5,10`)
+- `--repeat, -r` — Повторов замера (по умолчанию 2)
+- `--warmup, -w` — Прогревочных запусков (по умолчанию 1)
+- `--format, -f` — Формат отчёта: `pretty`, `csv`, `json`, `markdown`
+- `--help, -h` — Справка
+
+### Примеры запуска
+
+- **Все бенчмарки для cherrypick:**
+  ```shell
+  dart run bin/main.dart --di=cherrypick --benchmark=all --format=markdown
+  ```
+
+- **Для get_it (все сценарии):**
+  ```shell
+  dart run bin/main.dart --di=getit --benchmark=all --format=markdown
+  ```
+
+- **Запуск по матрице параметров:**
+  ```shell
+  dart run bin/main.dart --benchmark=chainSingleton --chainCount=10,100 --nestingDepth=5,10 --repeat=3 --format=csv
+  ```
+
+---
+
+## Универсальная регистрация зависимостей: теперь через adapter
+
+В версии X.Y.Z вся логика сценариев регистрации DI-инфраструктуры локализована в adapter через метод `universalRegistration`.
+
+### Использование в Dart:
+
+```dart
+final di = CherrypickDIAdapter(); // или GetItAdapter(), RiverpodAdapter() и т.д.
+
+di.setupDependencies(
+  di.universalRegistration(
+    scenario: UniversalScenario.chain,
+    chainCount: 10,
+    nestingDepth: 5,
+    bindingMode: UniversalBindingMode.singletonStrategy,
+  ),
+);
+```
+- **Теперь нет необходимости вызывать глобальные функции или switch-case по типу DI!** Каждый adapter сам предоставляет типобезопасную функцию регистрации.
+
+### Как добавить новый сценарий или DI:
+
+- Реализуйте метод `universalRegistration<S extends Enum>(...)` в своём adapter.
+- Можно использовать как UniversalScenario, так и собственные enum-сценарии!
+- Бенчмарки CLI автоматически расширяются под ваш DI и ваши сценарии, если реализован метод-расширение.
+
+### Запуск CLI (все сценарии DI Cherrypick, GetIt, Riverpod):
+
+```
+dart run bin/main.dart --di=cherrypick --benchmark=all
+dart run bin/main.dart --di=getit --benchmark=all
+dart run bin/main.dart --di=riverpod --benchmark=all
+```
+
+Смотрите примеры готовых adapters в `benchmark_di/lib/di_adapters/`.
+
+## Преимущества
+
+- **Type-safe:** Исключено использование dynamic/object в стороне DI.
+- **Масштабируемость:** Новый сценарий — просто enum + метод в adapter.
+- **Вся логика регистрации теперь только в adapter:** Добавление или изменение не затрагивает глобальные функции.
+
+
+---
+
+## Архитектура
+
+```mermaid
+classDiagram
+    class BenchmarkCliRunner {
+        +run(args)
+    }
+    class UniversalChainBenchmark~TContainer~ {
+        +setup()
+        +run()
+        +teardown()
+    }
+    class UniversalChainAsyncBenchmark~TContainer~ {
+        +setup()
+        +run()
+        +teardown()
+    }
+    class DIAdapter~TContainer~ {
+        <<interface>>
+        +setupDependencies(cb)
+        +resolve~T~(named)
+        +resolveAsync~T~(named)
+        +teardown()
+        +openSubScope(name)
+        +waitForAsyncReady()
+        +universalRegistration<S extends Enum>(...)
+    }
+    class CherrypickDIAdapter
+    class GetItAdapter
+    class RiverpodAdapter
+    class UniversalChainModule {
+        +builder(scope)
+        +chainCount
+        +nestingDepth
+        +bindingMode
+        +scenario
+    }
+    class UniversalService {
+        <<interface>>
+        +value
+        +dependency
+    }
+    class UniversalServiceImpl {
+        +UniversalServiceImpl(value, dependency)
+    }
+    class Scope
+    class UniversalScenario
+    class UniversalBindingMode
+
+    %% Relationships
+
+    BenchmarkCliRunner --> UniversalChainBenchmark
+    BenchmarkCliRunner --> UniversalChainAsyncBenchmark
+
+    UniversalChainBenchmark *-- DIAdapter
+    UniversalChainAsyncBenchmark *-- DIAdapter
+
+    DIAdapter <|.. CherrypickDIAdapter
+    DIAdapter <|.. GetItAdapter
+    DIAdapter <|.. RiverpodAdapter
+
+    CherrypickDIAdapter ..> Scope
+    GetItAdapter ..> GetIt: "uses GetIt"
+    RiverpodAdapter ..> Map~String, ProviderBase~: "uses Provider registry"
+
+    DIAdapter o--> UniversalChainModule : setupDependencies
+
+    UniversalChainModule ..> UniversalScenario
+    UniversalChainModule ..> UniversalBindingMode
+
+    UniversalChainModule o-- UniversalServiceImpl : creates
+    UniversalService <|.. UniversalServiceImpl
+    UniversalServiceImpl --> UniversalService : dependency
+
+    %% 
+    %% Each concrete adapter implements universalRegistration<S extends Enum>
+    %% You can add new scenario enums for custom adapters
+    %% Extensibility is achieved via adapter logic, not global functions
+```
+
+---
+
+## Метрики
+
+Всегда собираются:
+- **Время** (мкс): среднее, медиана, stddev, min, max
+- **Память**: прирост RSS, пиковое значение RSS
+
+## Лицензия
+
+MIT

benchmark_di/REPORT.md

@@ -0,0 +1,79 @@
+# DI Benchmark Results: cherrypick vs get_it
+
+## Benchmark parameters
+
+| Parameter         | Value                  |
+|------------------|-----------------------|
+| --benchmark      | all                   |
+| --chainCount (-c)| 10, 100               |
+| --nestingDepth (-d)| 10, 100             |
+| --repeat (-r)    | 2                     |
+| --warmup (-w)    | 1 (default)           |
+| --format (-f)    | markdown              |
+| --di             | cherrypick, get_it    |
+
+---
+
+## Benchmark scenarios
+
+**(1) RegisterSingleton**
+Registers and resolves a singleton. Baseline DI speed.
+
+**(2) ChainSingleton**
+A dependency chain A → B → ... → N (singleton). Measures how fast DI resolves deep singleton chains by name.
+
+**(3) ChainFactory**
+Same as ChainSingleton, but every chain element is a factory. Shows DI speed for stateless 'creation chain'.
+
+**(4) AsyncChain**
+Async chain (async factory). Measures DI performance for async graphs.
+
+**(5) Named**
+Registers two bindings with names ("impl1", "impl2"), resolves by name. Tests named lookup.
+
+**(6) Override**
+Registers a chain/alias in a child scope and resolves UniversalService without a name in that scope. Simulates override and modular/test architecture.
+
+---
+
+## Comparative Table (Mean, ΔRSS), chainCount=10, nestingDepth=10
+
+| Scenario           | cherrypick Mean (us) | cherrypick ΔRSS | get_it Mean (us) | get_it ΔRSS |
+|--------------------|---------------------:|----------------:|-----------------:|------------:|
+| RegisterSingleton  | 21.0                 | 320             | 24.5             | 80          |
+| ChainSingleton     | 112.5                | -3008           | 2.0              | 304         |
+| ChainFactory       | 8.0                  | 0               | 4.0              | 0           |
+| AsyncChain         | 36.5                 | 0               | 13.5             | 0           |
+| Named              | 1.5                  | 0               | 0.5              | 0           |
+| Override           | 27.5                 | 0               | 0.0              | 0           |
+
+## Maximum load: chainCount=100, nestingDepth=100
+
+| Scenario           | cherrypick Mean (us) | cherrypick ΔRSS | get_it Mean (us) | get_it ΔRSS |
+|--------------------|---------------------:|----------------:|-----------------:|------------:|
+| RegisterSingleton  | 1.0                  | 32              | 1.0              | 0           |
+| ChainSingleton     | 3884.0               | 0               | 1.5              | 34848       |
+| ChainFactory       | 4088.0               | 0               | 50.0             | 12528       |
+| AsyncChain         | 4287.0               | 0               | 17.0             | 63120       |
+| Named              | 1.0                  | 0               | 0.0              | 0           |
+| Override           | 4767.5               | 0               | 1.5              | 14976       |
+
+---
+
+## Scenario explanations
+
+- **RegisterSingleton:** Registers and resolves a singleton dependency, baseline test for cold/hot startup speed.
+- **ChainSingleton:** Deep chain of singleton dependencies. Cherrypick is much slower as depth increases; get_it is nearly unaffected.
+- **ChainFactory:** Creation chain with new instances per resolve. get_it generally faster on large chains due to ultra-simple factory registration.
+- **AsyncChain:** Async factory chain. get_it processes async resolutions much faster; cherrypick is much slower as depth increases due to async handling.
+- **Named:** Both DI containers resolve named bindings nearly instantly, even on large graphs.
+- **Override:** Child scope override. get_it (thanks to stack-based scopes) resolves immediately; cherrypick supports modular testing with controlled memory use.
+
+## Summary
+
+- **get_it** demonstrates impressive speed and low overhead across all scenarios and loads, but lacks diagnostics, advanced scopes, and cycle detection.
+- **cherrypick** is ideal for complex, multi-layered, production or testable architectures where scope, overrides, and diagnostics are critical. Predictably slower on deep/wide graphs, but scales well and provides extra safety.
+
+**Recommendation:**
+- Use cherrypick for enterprise, multi-feature/testable DI needs.
+- Use get_it for fast games, scripts, tiny Apps, and hot demos.

benchmark_di/REPORT.ru.md

@@ -0,0 +1,79 @@
+# Результаты бенчмарка DI: cherrypick vs get_it
+
+## Параметры запуска бенчмарков
+
+| Параметр         | Значение                 |
+|------------------|-------------------------|
+| --benchmark      | all                     |
+| --chainCount (-c)| 10, 100                 |
+| --nestingDepth (-d)| 10, 100               |
+| --repeat (-r)    | 2                       |
+| --warmup (-w)    | 1 (по умолчанию)        |
+| --format (-f)    | markdown                |
+| --di             | cherrypick, get_it      |
+
+---
+
+## Описание бенчмарков
+
+**(1) RegisterSingleton**  
+Регистрируется и дважды резолвится singleton. Базовый тест скорости DI.
+
+**(2) ChainSingleton**  
+Цепочка зависимостей A → B → ... → N (singleton). Тестирует скорость заполнения и разрешения глубоких singleton-цепочек по имени.
+
+**(3) ChainFactory**  
+Аналогично ChainSingleton, но каждое звено цепи — factory (новый объект при каждом resolve).
+
+**(4) AsyncChain**  
+Асинхронная цепочка (async factory). Важно для сценариев с async DI.
+
+**(5) Named**  
+Регистрируются две реализации по имени ('impl1', 'impl2'), разрешается named. Проверка lookup по имени.
+
+**(6) Override**  
+Регистрируется цепочка/alias в дочернем scope, резолвится UniversalService без имени там же. Симуляция override и изолированной/тестовой архитектуры.
+
+---
+
+## Сравнительная таблица (Mean (us), ΔRSS(KB)), chainCount=10, nestingDepth=10
+
+| Сценарий          | cherrypick Mean (мкс) | cherrypick ΔRSS | get_it Mean (мкс) | get_it ΔRSS |
+|-------------------|---------------------:|----------------:|-----------------:|------------:|
+| RegisterSingleton | 21.0                 | 320             | 24.5             | 80          |
+| ChainSingleton    | 112.5                | -3008           | 2.0              | 304         |
+| ChainFactory      | 8.0                  | 0               | 4.0              | 0           |
+| AsyncChain        | 36.5                 | 0               | 13.5             | 0           |
+| Named             | 1.5                  | 0               | 0.5              | 0           |
+| Override          | 27.5                 | 0               | 0.0              | 0           |
+
+## Максимальная нагрузка: chainCount=100, nestingDepth=100
+
+| Сценарий          | cherrypick Mean (мкс) | cherrypick ΔRSS | get_it Mean (мкс) | get_it ΔRSS |
+|-------------------|---------------------:|----------------:|-----------------:|------------:|
+| RegisterSingleton | 1.0                  | 32              | 1.0              | 0           |
+| ChainSingleton    | 3884.0               | 0               | 1.5              | 34848       |
+| ChainFactory      | 4088.0               | 0               | 50.0             | 12528       |
+| AsyncChain        | 4287.0               | 0               | 17.0             | 63120       |
+| Named             | 1.0                  | 0               | 0.0              | 0           |
+| Override          | 4767.5               | 0               | 1.5              | 14976       |
+
+---
+
+## Пояснения по сценариям
+
+- **RegisterSingleton** — базовый тест DI (регистрация и резолвинг singleton). Практически мгновенно у обоих DI.
+- **ChainSingleton** — глубокая singleton-цепочка. get_it вне конкуренции по скорости, cherrypick медленнее из-за более сложной логики поиска именованных зависимостей, но предсказуем.
+- **ChainFactory** — цепочка Factory-объектов. cherrypick заметно медленнее на длинных цепях, get_it почти не увеличивает время.
+- **AsyncChain** — асинхронная цепочка сервисов. get_it существенно быстрее, cherrypick страдает на глубине/ширине.
+- **Named** — разрешение зависимостей по имени. Оба DI почти мгновенны.
+- **Override** — переопределение alias без имени в дочернем scope. get_it (со стековыми scope) почти не теряет времени; cherrypick предсказуемо замедляется на глубине/ширине.
+
+## Итог
+
+- **get_it** выдаёт отличную производительность по всем сценариям, особенно на больших графах; но не поддерживает продвинутую диагностику, проверки циклов, расширенные scope.
+- **cherrypick** — незаменим для работы с корпоративными/тестируемыми архитектурами и наследованием, устойчиво ведёт себя на тысячи зависимостей, но требует учёта роста времени при экстремальных нагрузках.
+
+**Рекомендация:**
+- cherrypick — выбор для серьёзных production-систем и тестирования;
+- get_it — лидер для MVP, быстрых демо, прототипов, CLI, games.

benchmark_di/analysis_options.yaml

@@ -0,0 +1,34 @@
+# 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
+    depend_on_referenced_packages: 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_di/bin/main.dart

@@ -0,0 +1,5 @@
+import 'package:benchmark_di/cli/benchmark_cli.dart';
+
+Future<void> main(List<String> args) async {
+  await BenchmarkCliRunner().run(args);
+}

benchmark_di/lib/benchmarks/universal_chain_async_benchmark.dart

@@ -0,0 +1,41 @@
+import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+import 'package:benchmark_di/scenarios/universal_scenario.dart';
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:benchmark_di/di_adapters/di_adapter.dart';
+import 'package:benchmark_di/scenarios/universal_service.dart';
+
+class UniversalChainAsyncBenchmark<TContainer> extends AsyncBenchmarkBase {
+  final DIAdapter<TContainer> di;
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode mode;
+
+  UniversalChainAsyncBenchmark(
+    this.di, {
+    this.chainCount = 1,
+    this.nestingDepth = 3,
+    this.mode = UniversalBindingMode.asyncStrategy,
+  }) : super('UniversalAsync: asyncChain/$mode CD=$chainCount/$nestingDepth');
+
+  @override
+  Future<void> setup() async {
+    di.setupDependencies(di.universalRegistration(
+      chainCount: chainCount,
+      nestingDepth: nestingDepth,
+      bindingMode: mode,
+      scenario: UniversalScenario.asyncChain,
+    ));
+    await di.waitForAsyncReady();
+  }
+
+  @override
+  Future<void> teardown() async {
+    di.teardown();
+  }
+
+  @override
+  Future<void> run() async {
+    final serviceName = '${chainCount}_$nestingDepth';
+    await di.resolveAsync<UniversalService>(named: serviceName);
+  }
+}

benchmark_di/lib/benchmarks/universal_chain_benchmark.dart

@@ -0,0 +1,79 @@
+import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+import 'package:benchmark_di/scenarios/universal_scenario.dart';
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:benchmark_di/di_adapters/di_adapter.dart';
+import 'package:benchmark_di/scenarios/universal_service.dart';
+
+class UniversalChainBenchmark<TContainer> extends BenchmarkBase {
+  final DIAdapter<TContainer> _di;
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode mode;
+  final UniversalScenario scenario;
+  DIAdapter<TContainer>? _childDi;
+
+  UniversalChainBenchmark(
+    this._di, {
+    this.chainCount = 1,
+    this.nestingDepth = 3,
+    this.mode = UniversalBindingMode.singletonStrategy,
+    this.scenario = UniversalScenario.chain,
+  }) : super('Universal: $scenario/$mode CD=$chainCount/$nestingDepth');
+
+  @override
+  void setup() {
+    switch (scenario) {
+      case UniversalScenario.override:
+        _di.setupDependencies(_di.universalRegistration(
+          chainCount: chainCount,
+          nestingDepth: nestingDepth,
+          bindingMode: UniversalBindingMode.singletonStrategy,
+          scenario: UniversalScenario.chain,
+        ));
+        _childDi = _di.openSubScope('child');
+        _childDi!.setupDependencies(_childDi!.universalRegistration(
+          chainCount: chainCount,
+          nestingDepth: nestingDepth,
+          bindingMode: UniversalBindingMode.singletonStrategy,
+          scenario: UniversalScenario.chain,
+        ));
+        break;
+      default:
+        _di.setupDependencies(_di.universalRegistration(
+          chainCount: chainCount,
+          nestingDepth: nestingDepth,
+          bindingMode: mode,
+          scenario: scenario,
+        ));
+        break;
+    }
+  }
+
+  @override
+  void teardown() => _di.teardown();
+
+  @override
+  void run() {
+    switch (scenario) {
+      case UniversalScenario.register:
+        _di.resolve<UniversalService>();
+        break;
+      case UniversalScenario.named:
+        if (_di.runtimeType.toString().contains('GetItAdapter')) {
+          _di.resolve<UniversalService>(named: 'impl2');
+        } else {
+          _di.resolve<UniversalService>(named: 'impl2');
+        }
+        break;
+      case UniversalScenario.chain:
+        final serviceName = '${chainCount}_$nestingDepth';
+        _di.resolve<UniversalService>(named: serviceName);
+        break;
+      case UniversalScenario.override:
+        _childDi!.resolve<UniversalService>();
+        break;
+      case UniversalScenario.asyncChain:
+        throw UnsupportedError('asyncChain supported only in UniversalChainAsyncBenchmark');
+    }
+  }
+}

benchmark_di/lib/cli/benchmark_cli.dart

@@ -0,0 +1,133 @@
+import 'dart:math';
+
+import 'package:benchmark_di/cli/report/markdown_report.dart';
+import 'package:benchmark_di/scenarios/universal_scenario.dart';
+import 'package:cherrypick/cherrypick.dart';
+import 'package:get_it/get_it.dart';
+import 'package:riverpod/riverpod.dart' as rp;
+
+import 'report/pretty_report.dart';
+import 'report/csv_report.dart';
+import 'report/json_report.dart';
+import 'parser.dart';
+import 'runner.dart';
+import 'package:benchmark_di/benchmarks/universal_chain_benchmark.dart';
+import 'package:benchmark_di/benchmarks/universal_chain_async_benchmark.dart';
+import 'package:benchmark_di/di_adapters/cherrypick_adapter.dart';
+import 'package:benchmark_di/di_adapters/get_it_adapter.dart';
+import 'package:benchmark_di/di_adapters/riverpod_adapter.dart';
+
+/// Command-line interface (CLI) runner for benchmarks.
+///
+/// Parses CLI arguments, orchestrates benchmarks for different
+/// scenarios and configurations, collects results, and generates reports
+/// in the desired output format.
+class BenchmarkCliRunner {
+  /// Runs benchmarks based on CLI [args], configuring different test scenarios.
+  Future<void> run(List<String> args) async {
+    final config = parseBenchmarkCli(args);
+    final results = <Map<String, dynamic>>[];
+    for (final bench in config.benchesToRun) {
+      final scenario = toScenario(bench);
+      final mode = toMode(bench);
+      for (final c in config.chainCounts) {
+        for (final d in config.nestDepths) {
+          BenchmarkResult benchResult;
+          if (config.di == 'getit') {
+            final di = GetItAdapter();
+            if (scenario == UniversalScenario.asyncChain) {
+              final benchAsync = UniversalChainAsyncBenchmark<GetIt>(di,
+                chainCount: c, nestingDepth: d, mode: mode,
+              );
+              benchResult = await BenchmarkRunner.runAsync(
+                benchmark: benchAsync,
+                warmups: config.warmups,
+                repeats: config.repeats,
+              );
+            } else {
+              final benchSync = UniversalChainBenchmark<GetIt>(di,
+                chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+              );
+              benchResult = await BenchmarkRunner.runSync(
+                benchmark: benchSync,
+                warmups: config.warmups,
+                repeats: config.repeats,
+              );
+            }
+          } else if (config.di == 'riverpod') {
+            final di = RiverpodAdapter();
+            if (scenario == UniversalScenario.asyncChain) {
+              final benchAsync = UniversalChainAsyncBenchmark<Map<String, rp.ProviderBase<Object?>>>(di,
+                chainCount: c, nestingDepth: d, mode: mode,
+              );
+              benchResult = await BenchmarkRunner.runAsync(
+                benchmark: benchAsync,
+                warmups: config.warmups,
+                repeats: config.repeats,
+              );
+            } else {
+              final benchSync = UniversalChainBenchmark<Map<String, rp.ProviderBase<Object?>>>(di,
+                chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+              );
+              benchResult = await BenchmarkRunner.runSync(
+                benchmark: benchSync,
+                warmups: config.warmups,
+                repeats: config.repeats,
+              );
+            }
+          } else {
+            final di = CherrypickDIAdapter();
+            if (scenario == UniversalScenario.asyncChain) {
+              final benchAsync = UniversalChainAsyncBenchmark<Scope>(di,
+                chainCount: c, nestingDepth: d, mode: mode,
+              );
+              benchResult = await BenchmarkRunner.runAsync(
+                benchmark: benchAsync,
+                warmups: config.warmups,
+                repeats: config.repeats,
+              );
+            } else {
+              final benchSync = UniversalChainBenchmark<Scope>(di,
+                chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+              );
+              benchResult = await BenchmarkRunner.runSync(
+                benchmark: benchSync,
+                warmups: config.warmups,
+                repeats: config.repeats,
+              );
+            }
+          }
+          final timings = benchResult.timings;
+          timings.sort();
+          var mean = timings.reduce((a, b) => a + b) / timings.length;
+          var median = timings[timings.length ~/ 2];
+          var minVal = timings.first;
+          var maxVal = timings.last;
+          var stddev = timings.isEmpty ? 0 : sqrt(timings.map((x) => pow(x - mean, 2)).reduce((a, b) => a + b) / timings.length);
+          results.add({
+            'benchmark': 'Universal_$bench',
+            'chainCount': c,
+            'nestingDepth': d,
+            'mean_us': mean.toStringAsFixed(2),
+            'median_us': median.toStringAsFixed(2),
+            'stddev_us': stddev.toStringAsFixed(2),
+            'min_us': minVal.toStringAsFixed(2),
+            'max_us': maxVal.toStringAsFixed(2),
+            'trials': timings.length,
+            'timings_us': timings.map((t) => t.toStringAsFixed(2)).toList(),
+            'memory_diff_kb': benchResult.memoryDiffKb,
+            'delta_peak_kb': benchResult.deltaPeakKb,
+            'peak_rss_kb': benchResult.peakRssKb,
+          });
+        }
+      }
+    }
+    final reportGenerators = {
+      'pretty': PrettyReport(),
+      'csv': CsvReport(),
+      'json': JsonReport(),
+      'markdown': MarkdownReport(),
+    };
+    print(reportGenerators[config.format]?.render(results) ?? PrettyReport().render(results));
+  }
+}

benchmark_di/lib/cli/parser.dart

@@ -0,0 +1,130 @@
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+import 'package:benchmark_di/scenarios/universal_scenario.dart';
+
+/// Enum describing all supported Universal DI benchmark types.
+enum UniversalBenchmark {
+  /// Simple singleton registration benchmark
+  registerSingleton,
+  /// Chain of singleton dependencies
+  chainSingleton,
+  /// Chain using factories
+  chainFactory,
+  /// Async chain resolution
+  chainAsync,
+  /// Named registration benchmark
+  named,
+  /// Override/child-scope benchmark
+  override,
+}
+
+/// Maps [UniversalBenchmark] to the scenario enum for DI chains.
+UniversalScenario toScenario(UniversalBenchmark b) {
+  switch (b) {
+    case UniversalBenchmark.registerSingleton:
+      return UniversalScenario.register;
+    case UniversalBenchmark.chainSingleton:
+      return UniversalScenario.chain;
+    case UniversalBenchmark.chainFactory:
+      return UniversalScenario.chain;
+    case UniversalBenchmark.chainAsync:
+      return UniversalScenario.asyncChain;
+    case UniversalBenchmark.named:
+      return UniversalScenario.named;
+    case UniversalBenchmark.override:
+      return UniversalScenario.override;
+  }
+}
+
+/// Maps benchmark to registration mode (singleton/factory/async).
+UniversalBindingMode toMode(UniversalBenchmark b) {
+  switch (b) {
+    case UniversalBenchmark.registerSingleton:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.chainSingleton:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.chainFactory:
+      return UniversalBindingMode.factoryStrategy;
+    case UniversalBenchmark.chainAsync:
+      return UniversalBindingMode.asyncStrategy;
+    case UniversalBenchmark.named:
+      return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.override:
+      return UniversalBindingMode.singletonStrategy;
+  }
+}
+
+/// Utility to parse a string into its corresponding enum value [T].
+T parseEnum<T>(String value, List<T> values, T defaultValue) {
+  return values.firstWhere(
+    (v) => v.toString().split('.').last.toLowerCase() == value.toLowerCase(),
+    orElse: () => defaultValue,
+  );
+}
+
+/// Parses comma-separated integer list from [s].
+List<int> parseIntList(String s) =>
+    s.split(',').map((e) => int.tryParse(e.trim()) ?? 0).where((x) => x > 0).toList();
+
+/// CLI config describing what and how to benchmark.
+class BenchmarkCliConfig {
+  /// Benchmarks enabled to run (scenarios).
+  final List<UniversalBenchmark> benchesToRun;
+  /// List of chain counts (parallel, per test).
+  final List<int> chainCounts;
+  /// List of nesting depths (max chain length, per test).
+  final List<int> nestDepths;
+  /// How many times to repeat each trial.
+  final int repeats;
+  /// How many times to warm-up before measuring.
+  final int warmups;
+  /// Output report format.
+  final String format;
+  /// Name of DI implementation ("cherrypick" or "getit")
+  final String di;
+  BenchmarkCliConfig({
+    required this.benchesToRun,
+    required this.chainCounts,
+    required this.nestDepths,
+    required this.repeats,
+    required this.warmups,
+    required this.format,
+    required this.di,
+  });
+}
+
+/// Parses CLI arguments [args] into a [BenchmarkCliConfig].
+/// Supports --benchmark, --chainCount, --nestingDepth, etc.
+BenchmarkCliConfig parseBenchmarkCli(List<String> args) {
+  final parser = ArgParser()
+    ..addOption('benchmark', abbr: 'b', defaultsTo: 'chainSingleton')
+    ..addOption('chainCount', abbr: 'c', defaultsTo: '10')
+    ..addOption('nestingDepth', abbr: 'd', defaultsTo: '5')
+    ..addOption('repeat', abbr: 'r', defaultsTo: '2')
+    ..addOption('warmup', abbr: 'w', defaultsTo: '1')
+    ..addOption('format', abbr: 'f', defaultsTo: 'pretty')
+    ..addOption('di', defaultsTo: 'cherrypick', help: 'DI implementation: cherrypick, getit or riverpod')
+    ..addFlag('help', abbr: 'h', negatable: false, help: 'Show help');
+  final result = parser.parse(args);
+  if (result['help'] == true) {
+    print(parser.usage);
+    exit(0);
+  }
+  final benchName = result['benchmark'] as String;
+  final isAll = benchName == 'all';
+  final allBenches = UniversalBenchmark.values;
+  final benchesToRun = isAll
+      ? allBenches
+      : [parseEnum(benchName, allBenches, UniversalBenchmark.chainSingleton)];
+  return BenchmarkCliConfig(
+    benchesToRun: benchesToRun,
+    chainCounts: parseIntList(result['chainCount'] as String),
+    nestDepths: parseIntList(result['nestingDepth'] as String),
+    repeats: int.tryParse(result['repeat'] as String? ?? "") ?? 2,
+    warmups: int.tryParse(result['warmup'] as String? ?? "") ?? 1,
+    format: result['format'] as String,
+    di: result['di'] as String? ?? 'cherrypick',
+  );
+}

benchmark_di/lib/cli/report/csv_report.dart

@@ -0,0 +1,24 @@
+import 'report_generator.dart';
+
+/// Generates a CSV-formatted report for benchmark results.
+class CsvReport extends ReportGenerator {
+  /// List of all keys/columns to include in the CSV output.
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','timings_us','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+  /// Renders rows as a CSV table string.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final header = keys.join(',');
+    final lines = rows.map((r) =>
+      keys.map((k) {
+        final v = r[k];
+        if (v is List) return '"${v.join(';')}"';
+        return (v ?? '').toString();
+      }).join(',')
+    ).toList();
+    return ([header] + lines).join('\n');
+  }
+}

benchmark_di/lib/cli/report/json_report.dart

@@ -0,0 +1,13 @@
+import 'report_generator.dart';
+
+/// Generates a JSON-formatted report for benchmark results.
+class JsonReport extends ReportGenerator {
+  /// No specific keys; outputs all fields in raw map.
+  @override
+  List<String> get keys => [];
+  /// Renders all result rows as a pretty-printed JSON array.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    return '[\n${rows.map((r) => '  $r').join(',\n')}\n]';
+  }
+}

benchmark_di/lib/cli/report/markdown_report.dart

@@ -0,0 +1,78 @@
+import 'report_generator.dart';
+
+/// Generates a Markdown-formatted report for benchmark results.
+///
+/// Displays result rows as a visually clear Markdown table including a legend for all metrics.
+class MarkdownReport extends ReportGenerator {
+  /// List of columns (keys) to show in the Markdown table.
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+
+  /// Friendly display names for each benchmark type.
+  static const nameMap = {
+    'Universal_UniversalBenchmark.registerSingleton':'RegisterSingleton',
+    'Universal_UniversalBenchmark.chainSingleton':'ChainSingleton',
+    'Universal_UniversalBenchmark.chainFactory':'ChainFactory',
+    'Universal_UniversalBenchmark.chainAsync':'AsyncChain',
+    'Universal_UniversalBenchmark.named':'Named',
+    'Universal_UniversalBenchmark.override':'Override',
+  };
+
+  /// Renders all results as a formatted Markdown table with aligned columns and a legend.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final headers = [
+      'Benchmark', 'Chain Count', 'Depth', 'Mean (us)', 'Median', 'Stddev', 'Min', 'Max', 'N', 'ΔRSS(KB)', 'ΔPeak(KB)', 'PeakRSS(KB)'
+    ];
+    final dataRows = rows.map((r) {
+      final readableName = nameMap[r['benchmark']] ?? r['benchmark'];
+      return [
+        readableName,
+        r['chainCount'],
+        r['nestingDepth'],
+        r['mean_us'],
+        r['median_us'],
+        r['stddev_us'],
+        r['min_us'],
+        r['max_us'],
+        r['trials'],
+        r['memory_diff_kb'],
+        r['delta_peak_kb'],
+        r['peak_rss_kb'],
+      ].map((cell) => cell.toString()).toList();
+    }).toList();
+
+    // Calculate column width for pretty alignment
+    final all = [headers] + dataRows;
+    final widths = List.generate(headers.length, (i) {
+      return all.map((row) => row[i].length).reduce((a, b) => a > b ? a : b);
+    });
+
+    String rowToLine(List<String> row, {String sep = ' | '}) =>
+        '| ${List.generate(row.length, (i) => row[i].padRight(widths[i])).join(sep)} |';
+
+    final headerLine = rowToLine(headers);
+    final divider = '| ${widths.map((w) => '-' * w).join(' | ')} |';
+    final lines = dataRows.map(rowToLine).toList();
+
+    final legend = '''
+      > **Legend:**  
+      > `Benchmark` – Test name  
+      > `Chain Count` – Number of independent chains  
+      > `Depth` – Depth of each chain  
+      > `Mean (us)` – Average time per run (microseconds)  
+      > `Median` – Median time per run  
+      > `Stddev` – Standard deviation  
+      > `Min`, `Max` – Min/max run time  
+      > `N` – Number of measurements  
+      > `ΔRSS(KB)` – Change in process memory (KB)  
+      > `ΔPeak(KB)` – Change in peak RSS (KB)  
+      > `PeakRSS(KB)` – Max observed RSS memory (KB)  
+      ''';
+
+    return '$legend\n\n${([headerLine, divider] + lines).join('\n')}' ;
+  }
+}

benchmark_di/lib/cli/report/pretty_report.dart

@@ -0,0 +1,50 @@
+import 'report_generator.dart';
+
+/// Generates a human-readable, tab-delimited report for benchmark results.
+///
+/// Used for terminal and log output; shows each result as a single line with labeled headers.
+class PrettyReport extends ReportGenerator {
+  /// List of columns to output in the pretty report.
+  @override
+  final List<String> keys = [
+    'benchmark','chainCount','nestingDepth','mean_us','median_us','stddev_us',
+    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+  ];
+
+  /// Mappings from internal benchmark IDs to display names.
+  static const nameMap = {
+    'Universal_UniversalBenchmark.registerSingleton':    'RegisterSingleton',
+    'Universal_UniversalBenchmark.chainSingleton':       'ChainSingleton',
+    'Universal_UniversalBenchmark.chainFactory':         'ChainFactory',
+    'Universal_UniversalBenchmark.chainAsync':           'AsyncChain',
+    'Universal_UniversalBenchmark.named':                'Named',
+    'Universal_UniversalBenchmark.override':             'Override',
+  };
+
+  /// Renders the results as a header + tab-separated value table.
+  @override
+  String render(List<Map<String, dynamic>> rows) {
+    final headers = [
+      'Benchmark', 'Chain Count', 'Depth', 'Mean (us)', 'Median', 'Stddev', 'Min', 'Max', 'N', 'ΔRSS(KB)', 'ΔPeak(KB)', 'PeakRSS(KB)'
+    ];
+    final header = headers.join('\t');
+    final lines = rows.map((r) {
+      final readableName = nameMap[r['benchmark']] ?? r['benchmark'];
+      return [
+        readableName,
+        r['chainCount'],
+        r['nestingDepth'],
+        r['mean_us'],
+        r['median_us'],
+        r['stddev_us'],
+        r['min_us'],
+        r['max_us'],
+        r['trials'],
+        r['memory_diff_kb'],
+        r['delta_peak_kb'],
+        r['peak_rss_kb'],
+      ].join('\t');
+    }).toList();
+    return ([header] + lines).join('\n');
+  }
+}

benchmark_di/lib/cli/report/report_generator.dart

@@ -0,0 +1,9 @@
+/// Abstract base for generating benchmark result reports in different formats.
+///
+/// Subclasses implement [render] to output results, and [keys] to define columns (if any).
+abstract class ReportGenerator {
+  /// Renders the given [results] as a formatted string (table, markdown, csv, etc).
+  String render(List<Map<String, dynamic>> results);
+  /// List of output columns/keys included in the export (or [] for auto/all).
+  List<String> get keys;
+}

benchmark_di/lib/cli/runner.dart

@@ -0,0 +1,96 @@
+import 'dart:io';
+import 'dart:math';
+import 'package:benchmark_di/benchmarks/universal_chain_benchmark.dart';
+import 'package:benchmark_di/benchmarks/universal_chain_async_benchmark.dart';
+
+/// Holds the results for a single benchmark execution.
+class BenchmarkResult {
+  /// List of timings for each run (in microseconds).
+  final List<num> timings;
+  /// Difference in memory (RSS, in KB) after running.
+  final int memoryDiffKb;
+  /// Difference between peak RSS and initial RSS (in KB).
+  final int deltaPeakKb;
+  /// Peak RSS memory observed (in KB).
+  final int peakRssKb;
+  BenchmarkResult({
+    required this.timings,
+    required this.memoryDiffKb,
+    required this.deltaPeakKb,
+    required this.peakRssKb,
+  });
+  /// Computes a BenchmarkResult instance from run timings and memory data.
+  factory BenchmarkResult.collect({
+    required List<num> timings,
+    required List<int> rssValues,
+    required int memBefore,
+  }) {
+    final memAfter = ProcessInfo.currentRss;
+    final memDiffKB = ((memAfter - memBefore) / 1024).round();
+    final peakRss = [...rssValues, memBefore].reduce(max);
+    final deltaPeakKb = ((peakRss - memBefore) / 1024).round();
+    return BenchmarkResult(
+      timings: timings,
+      memoryDiffKb: memDiffKB,
+      deltaPeakKb: deltaPeakKb,
+      peakRssKb: (peakRss / 1024).round(),
+    );
+  }
+}
+
+/// Static methods to execute and time benchmarks for DI containers.
+class BenchmarkRunner {
+  /// Runs a synchronous benchmark ([UniversalChainBenchmark]) for a given number of [warmups] and [repeats].
+  /// Collects execution time and observed memory.
+  static Future<BenchmarkResult> runSync({
+    required UniversalChainBenchmark benchmark,
+    required int warmups,
+    required int repeats,
+  }) async {
+    final timings = <num>[];
+    final rssValues = <int>[];
+    for (int i = 0; i < warmups; i++) {
+      benchmark.setup();
+      benchmark.run();
+      benchmark.teardown();
+    }
+    final memBefore = ProcessInfo.currentRss;
+    for (int i = 0; i < repeats; i++) {
+      benchmark.setup();
+      final sw = Stopwatch()..start();
+      benchmark.run();
+      sw.stop();
+      timings.add(sw.elapsedMicroseconds);
+      rssValues.add(ProcessInfo.currentRss);
+      benchmark.teardown();
+    }
+    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+  }
+
+  /// Runs an asynchronous benchmark ([UniversalChainAsyncBenchmark]) for a given number of [warmups] and [repeats].
+  /// Collects execution time and observed memory.
+  static Future<BenchmarkResult> runAsync({
+    required UniversalChainAsyncBenchmark benchmark,
+    required int warmups,
+    required int repeats,
+  }) async {
+    final timings = <num>[];
+    final rssValues = <int>[];
+    for (int i = 0; i < warmups; i++) {
+      await benchmark.setup();
+      await benchmark.run();
+      await benchmark.teardown();
+    }
+    final memBefore = ProcessInfo.currentRss;
+    for (int i = 0; i < repeats; i++) {
+      await benchmark.setup();
+      final sw = Stopwatch()..start();
+      await benchmark.run();
+      sw.stop();
+      timings.add(sw.elapsedMicroseconds);
+      rssValues.add(ProcessInfo.currentRss);
+      await benchmark.teardown();
+    }
+    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+  }
+}

benchmark_di/lib/di_adapters/cherrypick_adapter.dart

@@ -0,0 +1,188 @@
+import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+import 'package:benchmark_di/scenarios/universal_scenario.dart';
+import 'package:benchmark_di/scenarios/universal_service.dart';
+import 'package:cherrypick/cherrypick.dart';
+import 'di_adapter.dart';
+
+
+/// Test module that generates a chain of service bindings for benchmarking.
+///
+/// Configurable by chain count, nesting depth, binding mode, and scenario
+/// to support various DI performance tests (singleton, factory, async, etc).
+class UniversalChainModule extends Module {
+  /// Number of chains to create.
+  final int chainCount;
+  /// Depth of each chain.
+  final int nestingDepth;
+  /// How modules are registered (factory/singleton/async).
+  final UniversalBindingMode bindingMode;
+  /// Which di scenario to generate (chained, named, etc).
+  final UniversalScenario scenario;
+
+  /// Constructs a configured test DI module for the benchmarks.
+  UniversalChainModule({
+    required this.chainCount,
+    required this.nestingDepth,
+    this.bindingMode = UniversalBindingMode.singletonStrategy,
+    this.scenario = UniversalScenario.chain,
+  });
+
+  @override
+  void builder(Scope currentScope) {
+    if (scenario == UniversalScenario.asyncChain) {
+      // Generate async chain with singleton async bindings.
+      for (var chainIndex = 0; chainIndex < chainCount; chainIndex++) {
+        for (var levelIndex = 0; levelIndex < nestingDepth; levelIndex++) {
+          final chain = chainIndex + 1;
+          final level = levelIndex + 1;
+          final prevDepName = '${chain}_${level - 1}';
+          final depName = '${chain}_$level';
+          bind<UniversalService>()
+            .toProvideAsync(() async {
+              final prev = level > 1
+                  ? await currentScope.resolveAsync<UniversalService>(named: prevDepName)
+                  : null;
+              return UniversalServiceImpl(
+                value: depName,
+                dependency: prev,
+              );
+            })
+            .withName(depName)
+            .singleton();
+        }
+      }
+      return;
+    }
+
+    switch (scenario) {
+      case UniversalScenario.register:
+        // Simple singleton registration.
+        bind<UniversalService>()
+            .toProvide(() => UniversalServiceImpl(value: 'reg', dependency: null))
+            .singleton();
+        break;
+      case UniversalScenario.named:
+        // Named factory registration for two distinct objects.
+        bind<UniversalService>().toProvide(() => UniversalServiceImpl(value: 'impl1')).withName('impl1');
+        bind<UniversalService>().toProvide(() => UniversalServiceImpl(value: 'impl2')).withName('impl2');
+        break;
+      case UniversalScenario.chain:
+        // Chain of nested services, with dependency on previous level by name.
+        for (var chainIndex = 0; chainIndex < chainCount; chainIndex++) {
+          for (var levelIndex = 0; levelIndex < nestingDepth; levelIndex++) {
+            final chain = chainIndex + 1;
+            final level = levelIndex + 1;
+            final prevDepName = '${chain}_${level - 1}';
+            final depName = '${chain}_$level';
+            switch (bindingMode) {
+              case UniversalBindingMode.singletonStrategy:
+                bind<UniversalService>()
+                    .toProvide(() => UniversalServiceImpl(
+                          value: depName,
+                          dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                        ))
+                    .withName(depName)
+                    .singleton();
+                break;
+              case UniversalBindingMode.factoryStrategy:
+                bind<UniversalService>()
+                    .toProvide(() => UniversalServiceImpl(
+                          value: depName,
+                          dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                        ))
+                    .withName(depName);
+                break;
+              case UniversalBindingMode.asyncStrategy:
+                bind<UniversalService>()
+                    .toProvideAsync(() async => UniversalServiceImpl(
+                          value: depName,
+                          dependency: await currentScope.resolveAsync<UniversalService>(named: prevDepName),
+                        ))
+                    .withName(depName)
+                    .singleton();
+                break;
+            }
+          }
+        }
+        // Регистрация алиаса без имени (на последний элемент цепочки)
+        final depName = '${chainCount}_$nestingDepth';
+        bind<UniversalService>()
+            .toProvide(() => currentScope.resolve<UniversalService>(named: depName))
+            .singleton();
+        break;
+      case UniversalScenario.override:
+        // handled at benchmark level, но алиас нужен прямо в этом scope!
+        final depName = '${chainCount}_$nestingDepth';
+        bind<UniversalService>()
+            .toProvide(() => currentScope.resolve<UniversalService>(named: depName))
+            .singleton();
+        break;
+      case UniversalScenario.asyncChain:
+        // already handled above
+        break;
+    }
+  }
+}
+
+
+class CherrypickDIAdapter extends DIAdapter<Scope> {
+  Scope? _scope;
+  final bool _isSubScope;
+
+  CherrypickDIAdapter([Scope? scope, this._isSubScope = false]) {
+    _scope = scope;
+  }
+
+  @override
+  void setupDependencies(void Function(Scope container) registration) {
+    _scope ??= CherryPick.openRootScope();
+    registration(_scope!);
+  }
+
+  @override
+  Registration<Scope> universalRegistration<S extends Enum>({
+    required S scenario,
+    required int chainCount,
+    required int nestingDepth,
+    required UniversalBindingMode bindingMode,
+  }) {
+    if (scenario is UniversalScenario) {
+      return (scope) {
+        scope.installModules([
+          UniversalChainModule(
+            chainCount: chainCount,
+            nestingDepth: nestingDepth,
+            bindingMode: bindingMode,
+            scenario: scenario,
+          ),
+        ]);
+      };
+    }
+    throw UnsupportedError('Scenario $scenario not supported by CherrypickDIAdapter');
+  }
+
+  @override
+  T resolve<T extends Object>({String? named}) =>
+      _scope!.resolve<T>(named: named);
+
+  @override
+  Future<T> resolveAsync<T extends Object>({String? named}) async =>
+      _scope!.resolveAsync<T>(named: named);
+
+  @override
+  void teardown() {
+    if (!_isSubScope) {
+      CherryPick.closeRootScope();
+      _scope = null;
+    }
+    // SubScope teardown не требуется
+  }
+
+  @override
+  CherrypickDIAdapter openSubScope(String name) {
+    return CherrypickDIAdapter(_scope!.openSubScope(name), true);
+  }
+
+  @override
+  Future<void> waitForAsyncReady() async {}
+}

benchmark_di/lib/di_adapters/di_adapter.dart

@@ -0,0 +1,32 @@
+import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+/// Универсальная абстракция для DI-адаптера с унифицированной функцией регистрации.
+/// Теперь для каждого адаптера задаём строгий generic тип контейнера.
+typedef Registration<TContainer> = void Function(TContainer);
+
+abstract class DIAdapter<TContainer> {
+  /// Устанавливает зависимости с помощью строго типизированного контейнера.
+  void setupDependencies(void Function(TContainer container) registration);
+
+  /// Возвращает типобезопасную функцию регистрации зависимостей под конкретный сценарий.
+  Registration<TContainer> universalRegistration<S extends Enum>({
+    required S scenario,
+    required int chainCount,
+    required int nestingDepth,
+    required UniversalBindingMode bindingMode,
+  });
+
+  /// Резолвит (возвращает) экземпляр типа [T] (по имени, если требуется).
+  T resolve<T extends Object>({String? named});
+
+  /// Асинхронно резолвит экземпляр типа [T] (если нужно).
+  Future<T> resolveAsync<T extends Object>({String? named});
+
+  /// Уничтожает/отчищает DI-контейнер.
+  void teardown();
+
+  /// Открывает дочерний scope и возвращает новый адаптер (если поддерживается).
+  DIAdapter<TContainer> openSubScope(String name);
+
+  /// Ожидание готовности DI контейнера (если нужно для async DI).
+  Future<void> waitForAsyncReady() async {}
+}

benchmark_di/lib/di_adapters/get_it_adapter.dart

@@ -0,0 +1,156 @@
+import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+import 'package:benchmark_di/scenarios/universal_scenario.dart';
+import 'package:benchmark_di/scenarios/universal_service.dart';
+import 'package:get_it/get_it.dart';
+import 'di_adapter.dart';
+
+/// Универсальный DIAdapter для GetIt c поддержкой scopes и строгой типизацией.
+class GetItAdapter extends DIAdapter<GetIt> {
+  late GetIt _getIt;
+  final String? _scopeName;
+  final bool _isSubScope;
+  bool _scopePushed = false;
+
+  /// Основной (root) и subScope-конструкторы.
+  GetItAdapter({GetIt? instance, String? scopeName, bool isSubScope = false})
+      : _scopeName = scopeName,
+        _isSubScope = isSubScope {
+    if (instance != null) {
+      _getIt = instance;
+    }
+  }
+
+  @override
+  void setupDependencies(void Function(GetIt container) registration) {
+    if (_isSubScope) {
+      // Создаём scope через pushNewScope с init
+      _getIt.pushNewScope(
+        scopeName: _scopeName,
+        init: (getIt) => registration(getIt),
+      );
+      _scopePushed = true;
+    } else {
+      _getIt = GetIt.asNewInstance();
+      registration(_getIt);
+    }
+  }
+
+  @override
+  T resolve<T extends Object>({String? named}) =>
+      _getIt<T>(instanceName: named);
+
+  @override
+  Future<T> resolveAsync<T extends Object>({String? named}) async =>
+      _getIt<T>(instanceName: named);
+
+  @override
+  void teardown() {
+    if (_isSubScope && _scopePushed) {
+      _getIt.popScope();
+      _scopePushed = false;
+    } else {
+      _getIt.reset();
+    }
+  }
+
+  @override
+  GetItAdapter openSubScope(String name) =>
+      GetItAdapter(instance: _getIt, scopeName: name, isSubScope: true);
+
+  @override
+  Future<void> waitForAsyncReady() async {
+    await _getIt.allReady();
+  }
+
+  @override
+  Registration<GetIt> universalRegistration<S extends Enum>({
+    required S scenario,
+    required int chainCount,
+    required int nestingDepth,
+    required UniversalBindingMode bindingMode,
+  }) {
+    if (scenario is UniversalScenario) {
+      return (getIt) {
+        switch (scenario) {
+          case UniversalScenario.asyncChain:
+            for (int chain = 1; chain <= chainCount; chain++) {
+              for (int level = 1; level <= nestingDepth; level++) {
+                final prevDepName = '${chain}_${level - 1}';
+                final depName = '${chain}_$level';
+                getIt.registerSingletonAsync<UniversalService>(
+                  () async {
+                    final prev = level > 1
+                        ? await getIt.getAsync<UniversalService>(instanceName: prevDepName)
+                        : null;
+                    return UniversalServiceImpl(value: depName, dependency: prev);
+                  },
+                  instanceName: depName,
+                );
+              }
+            }
+            break;
+          case UniversalScenario.register:
+            getIt.registerSingleton<UniversalService>(UniversalServiceImpl(value: 'reg', dependency: null));
+            break;
+          case UniversalScenario.named:
+            getIt.registerFactory<UniversalService>(() => UniversalServiceImpl(value: 'impl1'), instanceName: 'impl1');
+            getIt.registerFactory<UniversalService>(() => UniversalServiceImpl(value: 'impl2'), instanceName: 'impl2');
+            break;
+          case UniversalScenario.chain:
+            for (int chain = 1; chain <= chainCount; chain++) {
+              for (int level = 1; level <= nestingDepth; level++) {
+                final prevDepName = '${chain}_${level - 1}';
+                final depName = '${chain}_$level';
+                switch (bindingMode) {
+                  case UniversalBindingMode.singletonStrategy:
+                    getIt.registerSingleton<UniversalService>(
+                      UniversalServiceImpl(
+                        value: depName,
+                        dependency: level > 1
+                          ? getIt<UniversalService>(instanceName: prevDepName)
+                          : null,
+                      ),
+                      instanceName: depName,
+                    );
+                    break;
+                  case UniversalBindingMode.factoryStrategy:
+                    getIt.registerFactory<UniversalService>(
+                      () => UniversalServiceImpl(
+                        value: depName,
+                        dependency: level > 1
+                            ? getIt<UniversalService>(instanceName: prevDepName)
+                            : null,
+                      ),
+                      instanceName: depName,
+                    );
+                    break;
+                  case UniversalBindingMode.asyncStrategy:
+                    getIt.registerSingletonAsync<UniversalService>(
+                      () async => UniversalServiceImpl(
+                        value: depName,
+                        dependency: level > 1
+                          ? await getIt.getAsync<UniversalService>(instanceName: prevDepName)
+                          : null,
+                      ),
+                      instanceName: depName,
+                    );
+                    break;
+                }
+              }
+            }
+            break;
+          case UniversalScenario.override:
+            // handled at benchmark level
+            break;
+        }
+        if (scenario == UniversalScenario.chain || scenario == UniversalScenario.override) {
+          final depName = '${chainCount}_$nestingDepth';
+          getIt.registerSingleton<UniversalService>(
+            getIt<UniversalService>(instanceName: depName),
+          );
+        }
+      };
+    }
+    throw UnsupportedError('Scenario $scenario not supported by GetItAdapter');
+  }
+}

benchmark_di/lib/di_adapters/riverpod_adapter.dart

@@ -0,0 +1,139 @@
+import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+import 'package:benchmark_di/scenarios/universal_scenario.dart';
+import 'package:benchmark_di/scenarios/universal_service.dart';
+import 'package:riverpod/riverpod.dart' as rp;
+import 'di_adapter.dart';
+
+/// Унифицированный DIAdapter для Riverpod с поддержкой scopes и строгой типизацией.
+class RiverpodAdapter extends DIAdapter<Map<String, rp.ProviderBase<Object?>>> {
+  rp.ProviderContainer? _container;
+  final Map<String, rp.ProviderBase<Object?>> _namedProviders;
+  final rp.ProviderContainer? _parent;
+  final bool _isSubScope;
+
+  RiverpodAdapter({
+    rp.ProviderContainer? container,
+    Map<String, rp.ProviderBase<Object?>>? providers,
+    rp.ProviderContainer? parent,
+    bool isSubScope = false,
+  })  : _container = container,
+        _namedProviders = providers ?? <String, rp.ProviderBase<Object?>>{},
+        _parent = parent,
+        _isSubScope = isSubScope;
+
+  @override
+  void setupDependencies(void Function(Map<String, rp.ProviderBase<Object?>> container) registration) {
+    _container ??= _parent == null
+        ? rp.ProviderContainer()
+        : rp.ProviderContainer(parent: _parent);
+    registration(_namedProviders);
+  }
+
+  @override
+  T resolve<T extends Object>({String? named}) {
+    final key = named ?? T.toString();
+    final provider = _namedProviders[key];
+    if (provider == null) {
+      throw Exception('Provider not found for $key');
+    }
+    return _container!.read(provider) as T;
+  }
+
+  @override
+  Future<T> resolveAsync<T extends Object>({String? named}) async {
+    final key = named ?? T.toString();
+    final provider = _namedProviders[key];
+    if (provider == null) {
+      throw Exception('Provider not found for $key');
+    }
+    // Если это FutureProvider — используем .future
+    if (provider.runtimeType.toString().contains('FutureProvider')) {
+      return await _container!.read((provider as dynamic).future) as T;
+    }
+    return resolve<T>(named: named);
+  }
+
+  @override
+  void teardown() {
+    _container?.dispose();
+    _container = null;
+    _namedProviders.clear();
+  }
+
+  @override
+  RiverpodAdapter openSubScope(String name) {
+    final newContainer = rp.ProviderContainer(parent: _container);
+    return RiverpodAdapter(
+      container: newContainer,
+      providers: Map.of(_namedProviders),
+      parent: _container,
+      isSubScope: true,
+    );
+  }
+
+  @override
+  Future<void> waitForAsyncReady() async {
+    // Riverpod синхронный по умолчанию.
+    return;
+  }
+
+  @override
+  Registration<Map<String, rp.ProviderBase<Object?>>> universalRegistration<S extends Enum>({
+    required S scenario,
+    required int chainCount,
+    required int nestingDepth,
+    required UniversalBindingMode bindingMode,
+  }) {
+    if (scenario is UniversalScenario) {
+      return (providers) {
+        switch (scenario) {
+          case UniversalScenario.register:
+            providers['UniversalService'] = rp.Provider<UniversalService>((ref) => UniversalServiceImpl(value: 'reg', dependency: null));
+            break;
+          case UniversalScenario.named:
+            providers['impl1'] = rp.Provider<UniversalService>((ref) => UniversalServiceImpl(value: 'impl1'));
+            providers['impl2'] = rp.Provider<UniversalService>((ref) => UniversalServiceImpl(value: 'impl2'));
+            break;
+          case UniversalScenario.chain:
+            for (int chain = 1; chain <= chainCount; chain++) {
+              for (int level = 1; level <= nestingDepth; level++) {
+                final prevDepName = '${chain}_${level - 1}';
+                final depName = '${chain}_$level';
+                providers[depName] = rp.Provider<UniversalService>((ref) => UniversalServiceImpl(
+                  value: depName,
+                  dependency: level > 1 ? ref.watch(providers[prevDepName] as rp.ProviderBase<UniversalService>) : null,
+                ));
+              }
+            }
+            final depName = '${chainCount}_$nestingDepth';
+            providers['UniversalService'] = rp.Provider<UniversalService>((ref) => ref.watch(providers[depName] as rp.ProviderBase<UniversalService>));
+            break;
+          case UniversalScenario.override:
+            // handled at benchmark level
+            break;
+          case UniversalScenario.asyncChain:
+            for (int chain = 1; chain <= chainCount; chain++) {
+              for (int level = 1; level <= nestingDepth; level++) {
+                final prevDepName = '${chain}_${level - 1}';
+                final depName = '${chain}_$level';
+                providers[depName] = rp.FutureProvider<UniversalService>((ref) async {
+                  return UniversalServiceImpl(
+                    value: depName,
+                    dependency: level > 1
+                        ? await ref.watch((providers[prevDepName] as rp.FutureProvider<UniversalService>).future) as UniversalService?
+                        : null,
+                  );
+                });
+              }
+            }
+            final depName = '${chainCount}_$nestingDepth';
+            providers['UniversalService'] = rp.FutureProvider<UniversalService>((ref) async {
+              return await ref.watch((providers[depName] as rp.FutureProvider<UniversalService>).future);
+            });
+            break;
+        }
+      };
+    }
+    throw UnsupportedError('Scenario $scenario not supported by RiverpodAdapter');
+  }
+}

benchmark_di/lib/scenarios/universal_binding_mode.dart

@@ -0,0 +1,11 @@
+/// Enum to represent the DI registration/binding mode.
+enum UniversalBindingMode {
+  /// Singleton/provider binding.
+  singletonStrategy,
+
+  /// Factory-based binding.
+  factoryStrategy,
+
+  /// Async-based binding.
+  asyncStrategy,
+}

benchmark_di/lib/scenarios/universal_scenario.dart

@@ -0,0 +1,13 @@
+/// Enum to represent which scenario is constructed for the benchmark.
+enum UniversalScenario {
+  /// Single registration.
+  register,
+  /// Chain of dependencies.
+  chain,
+  /// Named registrations.
+  named,
+  /// Child-scope override scenario.
+  override,
+  /// Asynchronous chain scenario.
+  asyncChain,
+}

benchmark_di/lib/scenarios/universal_service.dart

@@ -0,0 +1,17 @@
+
+/// Base interface for any universal service in the benchmarks.
+///
+/// Represents an object in the dependency chain with an identifiable value
+/// and (optionally) a dependency on a previous service in the chain.
+abstract class UniversalService {
+  /// String ID for this service instance (e.g. chain/level info).
+  final String value;
+  /// Optional reference to dependency service in the chain.
+  final UniversalService? dependency;
+  UniversalService({required this.value, this.dependency});
+}
+
+/// Default implementation for [UniversalService] used in service chains.
+class UniversalServiceImpl extends UniversalService {
+  UniversalServiceImpl({required super.value, super.dependency});
+}

benchmark_di/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_di/pubspec.lock

@@ -0,0 +1,132 @@
+# 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"
+  args:
+    dependency: "direct main"
+    description:
+      name: args
+      sha256: d0481093c50b1da8910eb0bb301626d4d8eb7284aa739614d2b394ee09e3ea04
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.7.0"
+  async:
+    dependency: transitive
+    description:
+      name: async
+      sha256: "758e6d74e971c3e5aceb4110bfd6698efc7f501675bcfe0c775459a8140750eb"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.13.0"
+  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.2"
+  collection:
+    dependency: transitive
+    description:
+      name: collection
+      sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.19.1"
+  exception_templates:
+    dependency: transitive
+    description:
+      name: exception_templates
+      sha256: "517f7c770da690073663f867ee2057ae2f4ffb28edae9da9faa624aa29ac76eb"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.1"
+  get_it:
+    dependency: "direct main"
+    description:
+      name: get_it
+      sha256: a4292e7cf67193f8e7c1258203104eb2a51ec8b3a04baa14695f4064c144297b
+      url: "https://pub.dev"
+    source: hosted
+    version: "8.2.0"
+  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"
+  path:
+    dependency: transitive
+    description:
+      name: path
+      sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.9.1"
+  riverpod:
+    dependency: "direct main"
+    description:
+      name: riverpod
+      sha256: "59062512288d3056b2321804332a13ffdd1bf16df70dcc8e506e411280a72959"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.6.1"
+  stack_trace:
+    dependency: transitive
+    description:
+      name: stack_trace
+      sha256: "8b27215b45d22309b5cddda1aa2b19bdfec9df0e765f2de506401c071d38d1b1"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.12.1"
+  state_notifier:
+    dependency: transitive
+    description:
+      name: state_notifier
+      sha256: b8677376aa54f2d7c58280d5a007f9e8774f1968d1fb1c096adcb4792fba29bb
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.0"
+sdks:
+  dart: ">=3.6.0 <4.0.0"

benchmark_di/pubspec.yaml

@@ -0,0 +1,19 @@
+name: benchmark_di
+version: 0.1.0
+publish_to: none
+description: Universal benchmark for any DI library (cherrypick, get_it, and others)
+
+environment:
+  sdk: '>=3.0.0 <4.0.0'
+
+dependencies:
+  cherrypick:
+    path: ../cherrypick
+  args: ^2.7.0
+  get_it: ^8.2.0
+  riverpod: ^2.6.1
+
+dev_dependencies:
+  lints: ^5.0.0
+  benchmark_harness: ^2.2.2
+  benchmark_runner: ^0.0.2

cherrypick/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 3.0.0-dev.5
+
+ - **REFACTOR**(scope): simplify _findBindingResolver<T> with one-liner and optional chaining.
+ - **PERF**(scope): speed up dependency lookup with Map-based binding resolver index.
+ - **DOCS**(perf): clarify Map-based resolver optimization applies since v3.0.0 in all docs.
+ - **DOCS**: update EN/RU quick start and tutorial with Fast Map-based lookup section; clarify performance benefit in README.
+
+## 3.0.0-dev.4
+
+ - **REFACTOR**(scope): simplify _findBindingResolver<T> with one-liner and optional chaining.
+ - **PERF**(scope): speed up dependency lookup with Map-based binding resolver index.
+ - **DOCS**(perf): clarify Map-based resolver optimization applies since v3.0.0 in all docs.
+ - **DOCS**: update EN/RU quick start and tutorial with Fast Map-based lookup section; clarify performance benefit in README.
+
+## 3.0.0-dev.3
+
+ - **REFACTOR**(scope): simplify _findBindingResolver<T> with one-liner and optional chaining.
+ - **PERF**(scope): speed up dependency lookup with Map-based binding resolver index.
+ - **DOCS**(perf): clarify Map-based resolver optimization applies since v3.0.0 in all docs.
+ - **DOCS**: update EN/RU quick start and tutorial with Fast Map-based lookup section; clarify performance benefit in README.
+
+## 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
@@ -95,6 +94,13 @@ final subScope = rootScope.openSubScope('featureScope')
 final dataBloc = await subScope.resolveAsync<DataBloc>();
 ```
 
+### Fast Dependency Lookup (Performance Improvement)
+
+> **Performance Note:**  
+> **Starting from version 3.0.0**, CherryPick uses a Map-based resolver index for dependency lookup. This means calls to `resolve<T>()` and related methods are now O(1) operations, regardless of the number of modules or bindings in your scope. Previously, the library had to iterate over all modules and bindings to locate the requested dependency, which could impact performance as your project grew.
+>
+> This optimization is internal and does not change any library APIs or usage patterns, but it significantly improves resolution speed in larger applications.
+
 ### Dependency Lookup API
 
 - `resolve<T>()` — Locates a dependency instance or throws if missing.
@@ -239,6 +245,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)

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);
@@ -39,6 +39,10 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
 
   final Set<Module> _modulesList = HashSet();
 
+  // индекс для мгновенного поиска binding’ов
+  final Map<Object, Map<String?, BindingResolver>> _bindingResolvers = {};
+
+
   /// RU: Генерирует уникальный идентификатор для скоупа.
   /// ENG: Generates unique identifier for scope.
   String _generateScopeId() {
@@ -96,6 +100,7 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     for (var module in modules) {
       module.builder(this);
     }
+    _rebuildResolversIndex();
     return this;
   }
 
@@ -107,7 +112,7 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
   Scope dropModules() {
     // [AlexeyYuPopkov](https://github.com/AlexeyYuPopkov) Thank you for the [Removed exception "ConcurrentModificationError"](https://github.com/pese-git/cherrypick/pull/2)
     _modulesList.clear();
-
+    _rebuildResolversIndex();
     return this;
   }
 
@@ -176,33 +181,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 +250,26 @@ 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) =>
+      _bindingResolvers[T]?[named] as BindingResolver<T>?;
+
+  // Индексируем все binding’и после каждого installModules/dropModules
+  void _rebuildResolversIndex() {
+    _bindingResolvers.clear();
+    for (var module in _modulesList) {
+      for (var binding in module.bindingSet) {
+        _bindingResolvers.putIfAbsent(binding.key, () => {});
+        final nameKey = binding.isNamed ? binding.name : null;
+        _bindingResolvers[binding.key]![nameKey] = binding.resolver!;
       }
     }
-    return _parentScope?._tryResolveAsyncInternal(named: named, params: params);
   }
 }

cherrypick/pubspec.yaml

@@ -1,10 +1,18 @@
 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.5
 homepage: https://pese-git.github.io/cherrypick-site/
 documentation: https://github.com/pese-git/cherrypick/wiki
 repository: https://github.com/pese-git/cherrypick
 issue_tracker: https://github.com/pese-git/cherrypick/issues
+topics:
+  - di
+  - ioc
+  - scope
+  - dependency-injection
+  - dependency-management
+  - inversion-of-control
+  - container
 
 environment:
   sdk: ">=3.5.2 <4.0.0"

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_annotations/pubspec.yaml

@@ -5,6 +5,14 @@ version: 1.1.0
 documentation: https://github.com/pese-git/cherrypick/wiki
 repository: https://github.com/pese-git/cherrypick/cherrypick_annotations
 issue_tracker: https://github.com/pese-git/cherrypick/issues
+topics:
+  - di
+  - ioc
+  - scope
+  - dependency-injection
+  - dependency-management
+  - inversion-of-control
+  - container
 
 environment:
   sdk: ">=3.5.2 <4.0.0"

cherrypick_flutter/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 1.1.3-dev.5
+
+ - Update a dependency to the latest release.
+
+## 1.1.3-dev.4
+
+ - Update a dependency to the latest release.
+
+## 1.1.3-dev.3
+
+ - Update a dependency to the latest release.
+
+## 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,10 +1,18 @@
 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.5
 homepage: https://pese-git.github.io/cherrypick-site/
 documentation: https://github.com/pese-git/cherrypick/wiki
 repository: https://github.com/pese-git/cherrypick
 issue_tracker: https://github.com/pese-git/cherrypick/issues
+topics:
+  - di
+  - ioc
+  - scope
+  - dependency-injection
+  - dependency-management
+  - inversion-of-control
+  - container
 
 environment:
   sdk: ">=3.5.2 <4.0.0"
@@ -13,7 +21,7 @@ environment:
 dependencies:
   flutter:
     sdk: flutter
-  cherrypick: ^3.0.0-dev.0
+  cherrypick: ^3.0.0-dev.5
 
 dev_dependencies:
   flutter_test:

cherrypick_generator/pubspec.yaml

@@ -6,6 +6,14 @@ version: 1.1.0
 documentation: https://github.com/pese-git/cherrypick/wiki
 repository: https://github.com/pese-git/cherrypick/cherrypick_generator
 issue_tracker: https://github.com/pese-git/cherrypick/issues
+topics:
+  - di
+  - ioc
+  - scope
+  - dependency-injection
+  - dependency-management
+  - inversion-of-control
+  - container
 
 environment:
   sdk: ">=3.5.2 <4.0.0"

doc/full_tutorial_en.md

@@ -177,6 +177,14 @@ final service = scope.tryResolve<OptionalService>(); // returns null if not exis
 
 ---
 
+### Fast Dependency Lookup (Performance Improvement)
+
+> **Performance Note:**  
+> **Starting from version 3.0.0**, CherryPick uses a Map-based resolver index for dependency lookup. This means calls to `resolve<T>()`, `tryResolve<T>()` and similar methods are now O(1) operations, regardless of the number of modules or bindings within your scope. Previously it would iterate over all modules and bindings, which could reduce performance as your project grew. This optimization is internal and does not affect the public API or usage patterns, but significantly improves resolution speed for larger applications.
+
+---
+
+
 ## Dependency injection with annotations & code generation
 
 CherryPick supports DI with annotations, letting you eliminate manual DI setup.

doc/full_tutorial_ru.md

@@ -178,6 +178,13 @@ final service = scope.tryResolve<OptionalService>(); // вернет null, ес
 
 ---
 
+### Быстрый поиск зависимостей (Performance Improvement)
+
+> **Примечание по производительности:**  
+> Начиная с версии **3.0.0**, CherryPick для поиска зависимости внутри scope использует Map-индекс. Благодаря этому методы `resolve<T>()`, `tryResolve<T>()` и аналогичные теперь работают за O(1), независимо от количества модулей и биндингов в вашем проекте. Ранее для поиска приходилось перебирать весь список вручную, что могло замедлять работу крупных приложений. Это внутреннее улучшение не меняет внешнего API или паттернов использования, но заметно ускоряет разрешение зависимостей на больших проектах.
+
+---
+
 ## Внедрение зависимостей через аннотации и автогенерацию
 
 CherryPick поддерживает DI через аннотации, что позволяет полностью избавиться от ручного внедрения зависимостей.

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_di
   - cherrypick
   - cherrypick_flutter
   - cherrypick_annotations

pubspec.lock

@@ -5,23 +5,23 @@ packages:
     dependency: transitive
     description:
       name: _fe_analyzer_shared
-      sha256: "16e298750b6d0af7ce8a3ba7c18c69c3785d11b15ec83f6dcd0ad2a0009b3cab"
+      sha256: "45cfa8471b89fb6643fe9bf51bd7931a76b8f5ec2d65de4fb176dba8d4f22c77"
       url: "https://pub.dev"
     source: hosted
-    version: "76.0.0"
+    version: "73.0.0"
   _macros:
     dependency: transitive
     description: dart
     source: sdk
-    version: "0.3.3"
+    version: "0.3.2"
   analyzer:
     dependency: transitive
     description:
       name: analyzer
-      sha256: "1f14db053a8c23e260789e9b0980fa27f2680dd640932cae5e1137cce0e46e1e"
+      sha256: "4959fec185fe70cce007c57e9ab6983101dbe593d2bf8bbfb4453aaec0cf470a"
       url: "https://pub.dev"
     source: hosted
-    version: "6.11.0"
+    version: "6.8.0"
   ansi_styles:
     dependency: transitive
     description:
@@ -298,10 +298,10 @@ packages:
     dependency: transitive
     description:
       name: macros
-      sha256: "1d9e801cd66f7ea3663c45fc708450db1fa57f988142c64289142c9b7ee80656"
+      sha256: "0acaed5d6b7eab89f63350bccd82119e6c602df0f391260d0e32b5e23db79536"
       url: "https://pub.dev"
     source: hosted
-    version: "0.1.3-main.0"
+    version: "0.1.2-main.4"
   matcher:
     dependency: transitive
     description: