chore(release): publish packages

- cherrypick@3.0.0-dev.10
 - cherrypick_annotations@1.1.2-dev.1
 - cherrypick_flutter@1.1.3-dev.10
 - cherrypick_generator@2.0.0-dev.1
 - talker_cherrypick_logger@1.1.0-dev.5

.gitignore

@@ -18,5 +18,7 @@ pubspec_overrides.yaml
 melos_cherrypick.iml
 melos_cherrypick_workspace.iml
 melos_cherrypick_flutter.iml
+melos_benchmark_di.iml
+melos_talker_cherrypick_logger.iml
 
 coverage

CHANGELOG.md

@@ -3,6 +3,186 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2025-08-15
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.10`](#cherrypick---v300-dev10)
+ - [`cherrypick_annotations` - `v1.1.2-dev.1`](#cherrypick_annotations---v112-dev1)
+ - [`cherrypick_flutter` - `v1.1.3-dev.10`](#cherrypick_flutter---v113-dev10)
+ - [`cherrypick_generator` - `v2.0.0-dev.1`](#cherrypick_generator---v200-dev1)
+ - [`talker_cherrypick_logger` - `v1.1.0-dev.5`](#talker_cherrypick_logger---v110-dev5)
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.10`
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+#### `cherrypick_annotations` - `v1.1.2-dev.1`
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+#### `cherrypick_flutter` - `v1.1.3-dev.10`
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+#### `cherrypick_generator` - `v2.0.0-dev.1`
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+#### `talker_cherrypick_logger` - `v1.1.0-dev.5`
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+
+## 2025-08-13
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`talker_cherrypick_logger` - `v1.1.0-dev.4`](#talker_cherrypick_logger---v110-dev4)
+
+---
+
+#### `talker_cherrypick_logger` - `v1.1.0-dev.4`
+
+ - **DOCS**(readme): update install instructions to use pub.dev as default method and remove obsolete git example.
+
+
+## 2025-08-13
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`talker_cherrypick_logger` - `v1.1.0-dev.3`](#talker_cherrypick_logger---v110-dev3)
+
+---
+
+#### `talker_cherrypick_logger` - `v1.1.0-dev.3`
+
+
+## 2025-08-13
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`talker_cherrypick_logger` - `v1.1.0-dev.2`](#talker_cherrypick_logger---v110-dev2)
+
+---
+
+#### `talker_cherrypick_logger` - `v1.1.0-dev.2`
+
+ - Bump "talker_cherrypick_logger" to `1.1.0-dev.2`.
+
+
+## 2025-08-13
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - [`cherrypick_generator` - `v2.0.0-dev.0`](#cherrypick_generator---v200-dev0)
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.9`](#cherrypick---v300-dev9)
+ - [`cherrypick_annotations` - `v1.1.2-dev.0`](#cherrypick_annotations---v112-dev0)
+ - [`cherrypick_flutter` - `v1.1.3-dev.9`](#cherrypick_flutter---v113-dev9)
+ - [`talker_cherrypick_logger` - `v1.1.0-dev.0`](#talker_cherrypick_logger---v110-dev0)
+
+---
+
+#### `cherrypick_generator` - `v2.0.0-dev.0`
+
+ - **BREAKING** **DOCS**(generator): improve and unify English documentation and examples for all DI source files.
+
+#### `cherrypick` - `v3.0.0-dev.9`
+
+ - **DOCS**(readme): add talker_cherrypick_logger to Additional Modules section.
+ - **DOCS**(api): improve all DI core code documentation with English dartdoc and examples.
+
+#### `cherrypick_annotations` - `v1.1.2-dev.0`
+
+ - **DOCS**(annotations): unify and improve English DartDoc for all DI annotations.
+
+#### `cherrypick_flutter` - `v1.1.3-dev.9`
+
+ - **DOCS**(provider): add detailed English API documentation for CherryPickProvider Flutter integration.
+
+#### `talker_cherrypick_logger` - `v1.1.0-dev.0`
+
+ - **FEAT**(logging): add talker_dio_logger and talker_bloc_logger integration, improve cherrypick logger structure, add UI log screen for DI and network/bloc debug.
+ - **DOCS**: add full English documentation and usage guide to README.md.
+ - **DOCS**: add detailed English documentation and usage examples for TalkerCherryPickObserver.
+
+
+## 2025-08-12
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.8`](#cherrypick---v300-dev8)
+ - [`cherrypick_flutter` - `v1.1.3-dev.8`](#cherrypick_flutter---v113-dev8)
+
+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.8`
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.8`
+
+ - **REFACTOR**(tests): replace MockLogger with MockObserver in scope tests to align with updated observer API.
+ - **FIX**(doc): remove hide symbol.
+ - **FEAT**(core): add full DI lifecycle observability via onInstanceDisposed.
+ - **DOCS**(logging): update Logging section in README with modern Observer usage and Talker integration examples.
+ - **DOCS**(observer): improve documentation, translate all comments to English, add usage examples.
+ - **DOCS**(README): add section with overview table for additional modules.
+ - **DOCS**(README): refactor structure and improve clarity of advanced features.
+ - **DOCS**(README): add 'Hierarchical Subscopes' section and update structure for advanced features clarity.
+
+
 ## 2025-08-11
 
 ### Changes

benchmark_di/lib/benchmarks/universal_chain_benchmark.dart

@@ -73,7 +73,8 @@ class UniversalChainBenchmark<TContainer> extends BenchmarkBase {
         _childDi!.resolve<UniversalService>();
         break;
       case UniversalScenario.asyncChain:
-        throw UnsupportedError('asyncChain supported only in UniversalChainAsyncBenchmark');
+        throw UnsupportedError(
+            'asyncChain supported only in UniversalChainAsyncBenchmark');
     }
   }
 }

benchmark_di/lib/cli/benchmark_cli.dart

@@ -36,8 +36,11 @@ class BenchmarkCliRunner {
           if (config.di == 'getit') {
             final di = GetItAdapter();
             if (scenario == UniversalScenario.asyncChain) {
-              final benchAsync = UniversalChainAsyncBenchmark<GetIt>(di,
+              final benchAsync = UniversalChainAsyncBenchmark<GetIt>(
-                chainCount: c, nestingDepth: d, mode: mode,
+                di,
+                chainCount: c,
+                nestingDepth: d,
+                mode: mode,
               );
               benchResult = await BenchmarkRunner.runAsync(
                 benchmark: benchAsync,
@@ -45,8 +48,12 @@ class BenchmarkCliRunner {
                 repeats: config.repeats,
               );
             } else {
-              final benchSync = UniversalChainBenchmark<GetIt>(di,
+              final benchSync = UniversalChainBenchmark<GetIt>(
-                chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+                di,
+                chainCount: c,
+                nestingDepth: d,
+                mode: mode,
+                scenario: scenario,
               );
               benchResult = await BenchmarkRunner.runSync(
                 benchmark: benchSync,
@@ -57,8 +64,12 @@ class BenchmarkCliRunner {
           } else if (config.di == 'riverpod') {
             final di = RiverpodAdapter();
             if (scenario == UniversalScenario.asyncChain) {
-              final benchAsync = UniversalChainAsyncBenchmark<Map<String, rp.ProviderBase<Object?>>>(di,
+              final benchAsync = UniversalChainAsyncBenchmark<
-                chainCount: c, nestingDepth: d, mode: mode,
+                  Map<String, rp.ProviderBase<Object?>>>(
+                di,
+                chainCount: c,
+                nestingDepth: d,
+                mode: mode,
               );
               benchResult = await BenchmarkRunner.runAsync(
                 benchmark: benchAsync,
@@ -66,8 +77,13 @@ class BenchmarkCliRunner {
                 repeats: config.repeats,
               );
             } else {
-              final benchSync = UniversalChainBenchmark<Map<String, rp.ProviderBase<Object?>>>(di,
+              final benchSync = UniversalChainBenchmark<
-                chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+                  Map<String, rp.ProviderBase<Object?>>>(
+                di,
+                chainCount: c,
+                nestingDepth: d,
+                mode: mode,
+                scenario: scenario,
               );
               benchResult = await BenchmarkRunner.runSync(
                 benchmark: benchSync,
@@ -78,8 +94,11 @@ class BenchmarkCliRunner {
           } else {
             final di = CherrypickDIAdapter();
             if (scenario == UniversalScenario.asyncChain) {
-              final benchAsync = UniversalChainAsyncBenchmark<Scope>(di,
+              final benchAsync = UniversalChainAsyncBenchmark<Scope>(
-                chainCount: c, nestingDepth: d, mode: mode,
+                di,
+                chainCount: c,
+                nestingDepth: d,
+                mode: mode,
               );
               benchResult = await BenchmarkRunner.runAsync(
                 benchmark: benchAsync,
@@ -87,8 +106,12 @@ class BenchmarkCliRunner {
                 repeats: config.repeats,
               );
             } else {
-              final benchSync = UniversalChainBenchmark<Scope>(di,
+              final benchSync = UniversalChainBenchmark<Scope>(
-                chainCount: c, nestingDepth: d, mode: mode, scenario: scenario,
+                di,
+                chainCount: c,
+                nestingDepth: d,
+                mode: mode,
+                scenario: scenario,
               );
               benchResult = await BenchmarkRunner.runSync(
                 benchmark: benchSync,
@@ -103,7 +126,11 @@ class BenchmarkCliRunner {
           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);
+          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,
@@ -128,6 +155,7 @@ class BenchmarkCliRunner {
       'json': JsonReport(),
       'markdown': MarkdownReport(),
     };
-    print(reportGenerators[config.format]?.render(results) ?? PrettyReport().render(results));
+    print(reportGenerators[config.format]?.render(results) ??
+        PrettyReport().render(results));
   }
 }

benchmark_di/lib/cli/parser.dart

@@ -8,14 +8,19 @@ import 'package:benchmark_di/scenarios/universal_scenario.dart';
 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,
 }
@@ -65,23 +70,32 @@ T parseEnum<T>(String value, List<T> values, T defaultValue) {
 }
 
 /// Parses comma-separated integer list from [s].
-List<int> parseIntList(String s) =>
+List<int> parseIntList(String s) => s
-    s.split(',').map((e) => int.tryParse(e.trim()) ?? 0).where((x) => x > 0).toList();
+    .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({
@@ -105,7 +119,9 @@ BenchmarkCliConfig parseBenchmarkCli(List<String> args) {
     ..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')
+    ..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) {

benchmark_di/lib/cli/report/csv_report.dart

@@ -5,20 +5,32 @@ 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',
+    'benchmark',
-    'min_us','max_us','trials','timings_us','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+    '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) =>
+    final lines = rows
-      keys.map((k) {
+        .map((r) => keys.map((k) {
-        final v = r[k];
+              final v = r[k];
-        if (v is List) return '"${v.join(';')}"';
+              if (v is List) return '"${v.join(';')}"';
-        return (v ?? '').toString();
+              return (v ?? '').toString();
-      }).join(',')
+            }).join(','))
-    ).toList();
+        .toList();
     return ([header] + lines).join('\n');
   }
 }

benchmark_di/lib/cli/report/json_report.dart

@@ -5,6 +5,7 @@ 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) {

benchmark_di/lib/cli/report/markdown_report.dart

@@ -7,25 +7,46 @@ 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',
+    'benchmark',
-    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+    '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.registerSingleton': 'RegisterSingleton',
-    'Universal_UniversalBenchmark.chainSingleton':'ChainSingleton',
+    'Universal_UniversalBenchmark.chainSingleton': 'ChainSingleton',
-    'Universal_UniversalBenchmark.chainFactory':'ChainFactory',
+    'Universal_UniversalBenchmark.chainFactory': 'ChainFactory',
-    'Universal_UniversalBenchmark.chainAsync':'AsyncChain',
+    'Universal_UniversalBenchmark.chainAsync': 'AsyncChain',
-    'Universal_UniversalBenchmark.named':'Named',
+    'Universal_UniversalBenchmark.named': 'Named',
-    'Universal_UniversalBenchmark.override':'Override',
+    '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)'
+      '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'];
@@ -73,6 +94,6 @@ class MarkdownReport extends ReportGenerator {
       > `PeakRSS(KB)` – Max observed RSS memory (KB)  
       ''';
 
-    return '$legend\n\n${([headerLine, divider] + lines).join('\n')}' ;
+    return '$legend\n\n${([headerLine, divider] + lines).join('\n')}';
   }
 }

benchmark_di/lib/cli/report/pretty_report.dart

@@ -7,25 +7,46 @@ 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',
+    'benchmark',
-    'min_us','max_us','trials','memory_diff_kb','delta_peak_kb','peak_rss_kb'
+    '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.registerSingleton': 'RegisterSingleton',
-    'Universal_UniversalBenchmark.chainSingleton':       'ChainSingleton',
+    'Universal_UniversalBenchmark.chainSingleton': 'ChainSingleton',
-    'Universal_UniversalBenchmark.chainFactory':         'ChainFactory',
+    'Universal_UniversalBenchmark.chainFactory': 'ChainFactory',
-    'Universal_UniversalBenchmark.chainAsync':           'AsyncChain',
+    'Universal_UniversalBenchmark.chainAsync': 'AsyncChain',
-    'Universal_UniversalBenchmark.named':                'Named',
+    'Universal_UniversalBenchmark.named': 'Named',
-    'Universal_UniversalBenchmark.override':             'Override',
+    '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)'
+      '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) {

benchmark_di/lib/cli/report/report_generator.dart

@@ -4,6 +4,7 @@
 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

@@ -7,10 +7,13 @@ import 'package:benchmark_di/benchmarks/universal_chain_async_benchmark.dart';
 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({
@@ -19,6 +22,7 @@ class BenchmarkResult {
     required this.deltaPeakKb,
     required this.peakRssKb,
   });
+
   /// Computes a BenchmarkResult instance from run timings and memory data.
   factory BenchmarkResult.collect({
     required List<num> timings,
@@ -64,7 +68,8 @@ class BenchmarkRunner {
       rssValues.add(ProcessInfo.currentRss);
       benchmark.teardown();
     }
-    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+    return BenchmarkResult.collect(
+        timings: timings, rssValues: rssValues, memBefore: memBefore);
   }
 
   /// Runs an asynchronous benchmark ([UniversalChainAsyncBenchmark]) for a given number of [warmups] and [repeats].
@@ -91,6 +96,7 @@ class BenchmarkRunner {
       rssValues.add(ProcessInfo.currentRss);
       await benchmark.teardown();
     }
-    return BenchmarkResult.collect(timings: timings, rssValues: rssValues, memBefore: memBefore);
+    return BenchmarkResult.collect(
+        timings: timings, rssValues: rssValues, memBefore: memBefore);
   }
 }

benchmark_di/lib/di_adapters/cherrypick_adapter.dart

@@ -4,7 +4,6 @@ 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
@@ -12,10 +11,13 @@ import 'di_adapter.dart';
 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;
 
@@ -38,17 +40,18 @@ class UniversalChainModule extends Module {
           final prevDepName = '${chain}_${level - 1}';
           final depName = '${chain}_$level';
           bind<UniversalService>()
-            .toProvideAsync(() async {
+              .toProvideAsync(() async {
-              final prev = level > 1
+                final prev = level > 1
-                  ? await currentScope.resolveAsync<UniversalService>(named: prevDepName)
+                    ? await currentScope.resolveAsync<UniversalService>(
-                  : null;
+                        named: prevDepName)
-              return UniversalServiceImpl(
+                    : null;
-                value: depName,
+                return UniversalServiceImpl(
-                dependency: prev,
+                  value: depName,
-              );
+                  dependency: prev,
-            })
+                );
-            .withName(depName)
+              })
-            .singleton();
+              .withName(depName)
+              .singleton();
         }
       }
       return;
@@ -58,13 +61,18 @@ class UniversalChainModule extends Module {
       case UniversalScenario.register:
         // Simple singleton registration.
         bind<UniversalService>()
-            .toProvide(() => UniversalServiceImpl(value: 'reg', dependency: null))
+            .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>()
-        bind<UniversalService>().toProvide(() => UniversalServiceImpl(value: 'impl2')).withName('impl2');
+            .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.
@@ -79,7 +87,8 @@ class UniversalChainModule extends Module {
                 bind<UniversalService>()
                     .toProvide(() => UniversalServiceImpl(
                           value: depName,
-                          dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                          dependency: currentScope.tryResolve<UniversalService>(
+                              named: prevDepName),
                         ))
                     .withName(depName)
                     .singleton();
@@ -88,7 +97,8 @@ class UniversalChainModule extends Module {
                 bind<UniversalService>()
                     .toProvide(() => UniversalServiceImpl(
                           value: depName,
-                          dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                          dependency: currentScope.tryResolve<UniversalService>(
+                              named: prevDepName),
                         ))
                     .withName(depName);
                 break;
@@ -96,7 +106,9 @@ class UniversalChainModule extends Module {
                 bind<UniversalService>()
                     .toProvideAsync(() async => UniversalServiceImpl(
                           value: depName,
-                          dependency: await currentScope.resolveAsync<UniversalService>(named: prevDepName),
+                          dependency:
+                              await currentScope.resolveAsync<UniversalService>(
+                                  named: prevDepName),
                         ))
                     .withName(depName)
                     .singleton();
@@ -107,14 +119,16 @@ class UniversalChainModule extends Module {
         // Регистрация алиаса без имени (на последний элемент цепочки)
         final depName = '${chainCount}_$nestingDepth';
         bind<UniversalService>()
-            .toProvide(() => currentScope.resolve<UniversalService>(named: depName))
+            .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))
+            .toProvide(
+                () => currentScope.resolve<UniversalService>(named: depName))
             .singleton();
         break;
       case UniversalScenario.asyncChain:
@@ -124,7 +138,6 @@ class UniversalChainModule extends Module {
   }
 }
 
-
 class CherrypickDIAdapter extends DIAdapter<Scope> {
   Scope? _scope;
   final bool _isSubScope;
@@ -158,7 +171,8 @@ class CherrypickDIAdapter extends DIAdapter<Scope> {
         ]);
       };
     }
-    throw UnsupportedError('Scenario $scenario not supported by CherrypickDIAdapter');
+    throw UnsupportedError(
+        'Scenario $scenario not supported by CherrypickDIAdapter');
   }
 
   @override

benchmark_di/lib/di_adapters/di_adapter.dart

@@ -1,4 +1,5 @@
 import 'package:benchmark_di/scenarios/universal_binding_mode.dart';
+
 /// Универсальная абстракция для DI-адаптера с унифицированной функцией регистрации.
 /// Теперь для каждого адаптера задаём строгий generic тип контейнера.
 typedef Registration<TContainer> = void Function(TContainer);

benchmark_di/lib/di_adapters/get_it_adapter.dart

@@ -80,9 +80,11 @@ class GetItAdapter extends DIAdapter<GetIt> {
                 getIt.registerSingletonAsync<UniversalService>(
                   () async {
                     final prev = level > 1
-                        ? await getIt.getAsync<UniversalService>(instanceName: prevDepName)
+                        ? await getIt.getAsync<UniversalService>(
+                            instanceName: prevDepName)
                         : null;
-                    return UniversalServiceImpl(value: depName, dependency: prev);
+                    return UniversalServiceImpl(
+                        value: depName, dependency: prev);
                   },
                   instanceName: depName,
                 );
@@ -90,11 +92,16 @@ class GetItAdapter extends DIAdapter<GetIt> {
             }
             break;
           case UniversalScenario.register:
-            getIt.registerSingleton<UniversalService>(UniversalServiceImpl(value: 'reg', dependency: null));
+            getIt.registerSingleton<UniversalService>(
+                UniversalServiceImpl(value: 'reg', dependency: null));
             break;
           case UniversalScenario.named:
-            getIt.registerFactory<UniversalService>(() => UniversalServiceImpl(value: 'impl1'), instanceName: 'impl1');
+            getIt.registerFactory<UniversalService>(
-            getIt.registerFactory<UniversalService>(() => UniversalServiceImpl(value: 'impl2'), instanceName: 'impl2');
+                () => UniversalServiceImpl(value: 'impl1'),
+                instanceName: 'impl1');
+            getIt.registerFactory<UniversalService>(
+                () => UniversalServiceImpl(value: 'impl2'),
+                instanceName: 'impl2');
             break;
           case UniversalScenario.chain:
             for (int chain = 1; chain <= chainCount; chain++) {
@@ -107,8 +114,8 @@ class GetItAdapter extends DIAdapter<GetIt> {
                       UniversalServiceImpl(
                         value: depName,
                         dependency: level > 1
-                          ? getIt<UniversalService>(instanceName: prevDepName)
+                            ? getIt<UniversalService>(instanceName: prevDepName)
-                          : null,
+                            : null,
                       ),
                       instanceName: depName,
                     );
@@ -129,8 +136,9 @@ class GetItAdapter extends DIAdapter<GetIt> {
                       () async => UniversalServiceImpl(
                         value: depName,
                         dependency: level > 1
-                          ? await getIt.getAsync<UniversalService>(instanceName: prevDepName)
+                            ? await getIt.getAsync<UniversalService>(
-                          : null,
+                                instanceName: prevDepName)
+                            : null,
                       ),
                       instanceName: depName,
                     );
@@ -143,7 +151,8 @@ class GetItAdapter extends DIAdapter<GetIt> {
             // handled at benchmark level
             break;
         }
-        if (scenario == UniversalScenario.chain || scenario == UniversalScenario.override) {
+        if (scenario == UniversalScenario.chain ||
+            scenario == UniversalScenario.override) {
           final depName = '${chainCount}_$nestingDepth';
           getIt.registerSingleton<UniversalService>(
             getIt<UniversalService>(instanceName: depName),

benchmark_di/lib/di_adapters/riverpod_adapter.dart

@@ -20,7 +20,9 @@ class RiverpodAdapter extends DIAdapter<Map<String, rp.ProviderBase<Object?>>> {
         _parent = parent;
 
   @override
-  void setupDependencies(void Function(Map<String, rp.ProviderBase<Object?>> container) registration) {
+  void setupDependencies(
+      void Function(Map<String, rp.ProviderBase<Object?>> container)
+          registration) {
     _container ??= _parent == null
         ? rp.ProviderContainer()
         : rp.ProviderContainer(parent: _parent);
@@ -76,7 +78,8 @@ class RiverpodAdapter extends DIAdapter<Map<String, rp.ProviderBase<Object?>>> {
   }
 
   @override
-  Registration<Map<String, rp.ProviderBase<Object?>>> universalRegistration<S extends Enum>({
+  Registration<Map<String, rp.ProviderBase<Object?>>>
+      universalRegistration<S extends Enum>({
     required S scenario,
     required int chainCount,
     required int nestingDepth,
@@ -86,25 +89,34 @@ class RiverpodAdapter extends DIAdapter<Map<String, rp.ProviderBase<Object?>>> {
       return (providers) {
         switch (scenario) {
           case UniversalScenario.register:
-            providers['UniversalService'] = rp.Provider<UniversalService>((ref) => UniversalServiceImpl(value: 'reg', dependency: null));
+            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['impl1'] = rp.Provider<UniversalService>(
-            providers['impl2'] = rp.Provider<UniversalService>((ref) => UniversalServiceImpl(value: 'impl2'));
+                (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(
+                providers[depName] =
-                  value: depName,
+                    rp.Provider<UniversalService>((ref) => UniversalServiceImpl(
-                  dependency: level > 1 ? ref.watch(providers[prevDepName] as rp.ProviderBase<UniversalService>) : null,
+                          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>));
+            providers['UniversalService'] = rp.Provider<UniversalService>(
+                (ref) => ref.watch(
+                    providers[depName] as rp.ProviderBase<UniversalService>));
             break;
           case UniversalScenario.override:
             // handled at benchmark level
@@ -114,24 +126,31 @@ class RiverpodAdapter extends DIAdapter<Map<String, rp.ProviderBase<Object?>>> {
               for (int level = 1; level <= nestingDepth; level++) {
                 final prevDepName = '${chain}_${level - 1}';
                 final depName = '${chain}_$level';
-                providers[depName] = rp.FutureProvider<UniversalService>((ref) async {
+                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?
+                        ? await ref.watch((providers[prevDepName]
+                                as rp.FutureProvider<UniversalService>)
+                            .future) as UniversalService?
                         : null,
                   );
                 });
               }
             }
             final depName = '${chainCount}_$nestingDepth';
-            providers['UniversalService'] = rp.FutureProvider<UniversalService>((ref) async {
+            providers['UniversalService'] =
-              return await ref.watch((providers[depName] as rp.FutureProvider<UniversalService>).future);
+                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');
+    throw UnsupportedError(
+        'Scenario $scenario not supported by RiverpodAdapter');
   }
 }

benchmark_di/lib/scenarios/universal_scenario.dart

@@ -2,12 +2,16 @@
 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

@@ -1,4 +1,3 @@
-
 /// Base interface for any universal service in the benchmarks.
 ///
 /// Represents an object in the dependency chain with an identifiable value
@@ -6,6 +5,7 @@
 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});

benchmark_di/pubspec.lock

@@ -47,7 +47,7 @@ packages:
       path: "../cherrypick"
       relative: true
     source: path
-    version: "3.0.0-dev.5"
+    version: "3.0.0-dev.9"
   collection:
     dependency: transitive
     description:

cherrypick/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 3.0.0-dev.10
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+## 3.0.0-dev.9
+
+ - **DOCS**(readme): add talker_cherrypick_logger to Additional Modules section.
+ - **DOCS**(api): improve all DI core code documentation with English dartdoc and examples.
+
+## 3.0.0-dev.8
+
+ - **REFACTOR**(tests): replace MockLogger with MockObserver in scope tests to align with updated observer API.
+ - **FIX**(doc): remove hide symbol.
+ - **FEAT**(core): add full DI lifecycle observability via onInstanceDisposed.
+ - **DOCS**(logging): update Logging section in README with modern Observer usage and Talker integration examples.
+ - **DOCS**(observer): improve documentation, translate all comments to English, add usage examples.
+ - **DOCS**(README): add section with overview table for additional modules.
+ - **DOCS**(README): refactor structure and improve clarity of advanced features.
+ - **DOCS**(README): add 'Hierarchical Subscopes' section and update structure for advanced features clarity.
+
 ## 3.0.0-dev.7
 
 > Note: This release has breaking changes.

cherrypick/README.md

@@ -13,7 +13,7 @@ It provides an easy-to-use system for registering, scoping, and resolving depend
   - [Binding](#binding)
   - [Module](#module)
   - [Scope](#scope)
-  - [Automatic Resource Cleanup with Disposable](#automatic-resource-cleanup-with-disposable)
+  - [Disposable](#disposable)
 - [Dependency Resolution API](#dependency-resolution-api)
 - [Using Annotations & Code Generation](#using-annotations--code-generation)
 - [Advanced Features](#advanced-features)
@@ -24,6 +24,7 @@ It provides an easy-to-use system for registering, scoping, and resolving depend
 - [Example Application](#example-application)
 - [FAQ](#faq)
 - [Documentation Links](#documentation-links)
+- [Additional Modules](#additional-modules)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -50,13 +51,14 @@ Add to your `pubspec.yaml`:
 ```yaml
 dependencies:
   cherrypick: ^<latest_version>
-```
+````
 
 Then run:
 
 ```shell
 dart pub get
 ```
+
 ---
 
 ## Getting Started
@@ -66,7 +68,6 @@ Here is a minimal example that registers and resolves a dependency:
 ```dart
 import 'package:cherrypick/cherrypick.dart';
 
-
 class AppModule extends Module {
   @override
   void builder(Scope currentScope) {
@@ -92,11 +93,11 @@ await CherryPick.closeRootScope();
 
 A **Binding** acts as a configuration for how to create or provide a particular dependency. Bindings support:
 
-- Direct instance assignment (`toInstance()`, `toInstanceAsync()`)
+* Direct instance assignment (`toInstance()`, `toInstanceAsync()`)
-- Lazy providers (sync/async functions)
+* Lazy providers (sync/async functions)
-- Provider functions supporting dynamic parameters
+* Provider functions supporting dynamic parameters
-- Named instances for resolving by string key
+* Named instances for resolving by string key
-- Optional singleton lifecycle
+* Optional singleton lifecycle
 
 #### Example
 
@@ -172,7 +173,7 @@ await CherryPick.closeRootScope();
 
 ---
 
-### Automatic Resource Cleanup with Disposable
+### Disposable
 
 CherryPick can automatically clean up any dependency that implements the `Disposable` interface. This makes resource management (for controllers, streams, sockets, files, etc.) easy and reliable—especially when scopes or the app are shut down.
 
@@ -223,67 +224,17 @@ await CherryPick.closeRootScope(); // awaits async disposal
 
 ---
 
-### Automatic resource management (`Disposable`, `dispose`)
+## Dependency Resolution API
 
-CherryPick automatically manages the lifecycle of any object registered via DI that implements the `Disposable` interface.
+- `resolve<T>()` — Locates a dependency instance or throws if missing.
+- `resolveAsync<T>()` — Async variant for dependencies requiring async binding.
+- `tryResolve<T>()` — Returns `null` if not found (sync).
+- `tryResolveAsync<T>()` — Returns `null` async if not found.
 
-**Best practice:**  
+Supports:
-Always finish your work with `await CherryPick.closeRootScope()` (for the root scope) or `await scope.closeSubScope('key')` (for subscopes).  
+- Synchronous and asynchronous dependencies
-These methods will automatically await `dispose()` on all resolved objects (e.g., singletons) that implement `Disposable`, ensuring proper and complete resource cleanup—sync or async.
+- Named dependencies
-
+- Provider functions with and without runtime parameters
-Manual `await scope.dispose()` may be useful if you manually manage custom scopes.
-
-#### Example
-
-```dart
-class MyService implements Disposable {
-  @override
-  FutureOr<void> dispose() async {
-    // release resources, close streams, perform async shutdown, etc.
-    print('MyService disposed!');
-  }
-}
-
-final scope = openRootScope();
-scope.installModules([
-  ModuleImpl(),
-]);
-
-final service = scope.resolve<MyService>();
-
-// ... use service
-
-// Recommended completion:
-await CherryPick.closeRootScope(); // will print: MyService disposed!
-
-// Or, to close and clean up a subscope and its resources:
-await scope.closeSubScope('feature');
-
-class ModuleImpl extends Module {
-  @override
-  void builder(Scope scope) {
-    bind<MyService>().toProvide(() => MyService()).singleton();
-  }
-}
-```
-
-#### Working with Subscopes
-
-```dart
-// Open a named child scope (e.g., for a feature/module)
-final subScope = rootScope.openSubScope('featureScope')
-  ..installModules([FeatureModule()]);
-
-// Resolve from subScope, with fallback to parents if missing
-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.
 
 ---
 
@@ -337,7 +288,7 @@ class ProfilePage with _\$ProfilePage {
 }
 ```
 
-- After running build_runner, the mixin `_5ProfilePage` will be generated for field injection.
+- After running build_runner, the mixin `_ProfilePage` will be generated for field injection.
 - Call `myProfilePage.injectFields();` or use the mixin's auto-inject feature, and all dependencies will be set up for you.
 
 ---
@@ -423,17 +374,196 @@ abstract class AppModule {
 
 ---
 
-### Dependency Lookup API
+## Advanced Features
 
-- `resolve<T>()` — Locates a dependency instance or throws if missing.
+### Hierarchical Subscopes
-- `resolveAsync<T>()` — Async variant for dependencies requiring async binding.
-- `tryResolve<T>()` — Returns `null` if not found (sync).
-- `tryResolveAsync<T>()` — Returns `null` async if not found.
 
-Supports:
+CherryPick supports a hierarchical structure of scopes, allowing you to create complex and modular dependency graphs for advanced application architectures. Each subscope inherits from its parent, enabling context-specific overrides while still allowing access to global or shared services.
-- Synchronous and asynchronous dependencies
+
-- Named dependencies
+#### Key Points
-- Provider functions with and without runtime parameters
+
+- **Subscopes** are child scopes that can be opened from any existing scope (including the root).
+- Dependencies registered in a subscope override those from parent scopes when resolved.
+- If a dependency is not found in the current subscope, the resolution process automatically searches parent scopes up the hierarchy.
+- Subscopes can have their own modules, lifetime, and disposable objects.
+- You can nest subscopes to any depth, modeling features, flows, or components independently.
+
+#### Example
+
+```dart
+final rootScope = CherryPick.openRootScope();
+rootScope.installModules([AppModule()]);
+
+// Open a hierarchical subscope for a feature or page
+final userFeatureScope = rootScope.openSubScope('userFeature');
+userFeatureScope.installModules([UserFeatureModule()]);
+
+// Dependencies defined in UserFeatureModule will take precedence
+final userService = userFeatureScope.resolve<UserService>();
+
+// If not found in the subscope, lookup continues in the parent (rootScope)
+final sharedService = userFeatureScope.resolve<SharedService>();
+
+// You can nest subscopes
+final dialogScope = userFeatureScope.openSubScope('dialog');
+dialogScope.installModules([DialogModule()]);
+final dialogManager = dialogScope.resolve<DialogManager>();
+```
+
+#### Use Cases
+
+- Isolate feature modules, flows, or screens with their own dependencies.
+- Provide and override services for specific navigation stacks or platform-specific branches.
+- Manage the lifetime and disposal of groups of dependencies independently (e.g., per-user, per-session, per-component).
+
+**Tip:** Always close subscopes when they are no longer needed to release resources and trigger cleanup of Disposable dependencies.
+
+---
+
+### Logging
+
+CherryPick lets you log all dependency injection (DI) events and errors using a flexible observer mechanism.
+
+#### Custom Observers
+
+You can pass any implementation of `CherryPickObserver` to your root scope or any sub-scope.
+This allows centralized and extensible logging, which you can direct to print, files, visualization frameworks, external loggers, or systems like [Talker](https://pub.dev/packages/talker).
+
+##### Example: Printing All Events
+
+```dart
+import 'package:cherrypick/cherrypick.dart';
+
+void main() {
+  // Use the built-in PrintCherryPickObserver for console logs
+  final observer = PrintCherryPickObserver();
+  final scope = CherryPick.openRootScope(observer: observer);
+  // All DI actions and errors will now be printed!
+}
+```
+
+##### Example: Advanced Logging with Talker
+
+For richer logging, analytics, or UI overlays, use an advanced observer such as [talker_cherrypick_logger](../talker_cherrypick_logger):
+
+```dart
+import 'package:cherrypick/cherrypick.dart';
+import 'package:talker/talker.dart';
+import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';
+
+void main() {
+  final talker = Talker();
+  final observer = TalkerCherryPickObserver(talker);
+  CherryPick.openRootScope(observer: observer);
+  // All container events go to the Talker log system!
+}
+```
+
+#### Default Behavior
+
+- By default, logging is silent (`SilentCherryPickObserver`) for production, with no output unless you supply an observer.
+- You can configure observers **per scope** for isolated, test-specific, or feature-specific logging.
+
+#### Observer Capabilities
+
+Events you can observe and log:
+- Dependency registration
+- Instance requests, creations, disposals
+- Module installs/removals
+- Scope opening/closing
+- Cache hits/misses
+- Cycle detection
+- Diagnostics, warnings, errors
+
+Just implement or extend `CherryPickObserver` and direct messages anywhere you want!
+
+#### When to Use
+
+- Enable verbose logging and debugging in development or test builds.
+- Route logs to your main log system or analytics.
+- Hook into DI lifecycle for profiling or monitoring.
+
+
+---
+
+### 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)
+
+---
+
+### Performance Improvements
+
+> **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.
+
+---
 
 ## Example Application
 
@@ -556,113 +686,7 @@ class ApiClientImpl implements ApiClient {
 }
 ```
 
-## Logging
+---
-
-CherryPick supports centralized logging of all dependency injection (DI) events and errors. You can globally enable logs for your application or test environment with:
-
-```dart
-import 'package:cherrypick/cherrypick.dart';
-
-void main() {
-  // Set a global logger before any scopes are created
-  CherryPick.setGlobalLogger(PrintLogger()); // or your custom logger
-
-  final scope = CherryPick.openRootScope();
-  // All DI actions and errors will now be logged!
-}
-```
-- All dependency resolution, scope creation, module installation, and circular dependency errors will be sent to your logger (via info/error method).
-- By default, logs are off (SilentLogger is used in production).
-
-If you want fine-grained, test-local, or isolated logging, you can provide a logger directly to each scope:
-
-```dart
-final logger = MockLogger();
-final scope = Scope(null, logger: logger); // works in tests for isolation
-scope.installModules([...]);
-```
-
-## Features
-
-- [x] Main Scope and Named Subscopes
-- [x] Named Instance Binding and Resolution
-- [x] Asynchronous and Synchronous Providers
-- [x] Providers Supporting Runtime Parameters
-- [x] Singleton Lifecycle Management
-- [x] Modular and Hierarchical Composition
-- [x] Null-safe Resolution (tryResolve/tryResolveAsync)
-- [x] Circular Dependency Detection (Local and Global)
-- [x] Comprehensive logging of dependency injection state and actions
-- [x] Automatic resource cleanup for all registered Disposable dependencies
-
-## 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)
-
 
 ## FAQ
 
@@ -671,15 +695,33 @@ try {
 **A:**  
 Yes! Even if none of your services currently implement `Disposable`, always use `await` when closing scopes. If you later add resource cleanup (by implementing `dispose()`), CherryPick will handle it automatically without you needing to change your scope cleanup code. This ensures resource management is future-proof, robust, and covers all application scenarios.
 
-## Documentation
+---
 
-- [Circular Dependency Detection (English)](doc/cycle_detection.en.md)
+## Documentation Links
-- [Обнаружение циклических зависимостей (Русский)](doc/cycle_detection.ru.md)
+
+* Circular Dependency Detection [(En)](doc/cycle_detection.en.md)[(Ru)](doc/cycle_detection.ru.md)
+
+---
+
+## Additional Modules
+
+CherryPick provides a set of official add-on modules for advanced use cases and specific platforms:
+
+| Module name | Description |
+|-------------|-------------|
+| [**cherrypick_annotations**](https://pub.dev/packages/cherrypick_annotations) | Dart annotations for concise DI definitions and code generation. |
+| [**cherrypick_generator**](https://pub.dev/packages/cherrypick_generator) | Code generator to produce DI bindings based on annotations. |
+| [**cherrypick_flutter**](https://pub.dev/packages/cherrypick_flutter) | Flutter integration: DI provider widgets and helpers for Flutter. |
+| [**talker_cherrypick_logger**](https://pub.dev/packages/talker_cherrypick_logger) | Advanced logger for CherryPick DI events and state. Provides seamless integration with [Talker](https://pub.dev/packages/talker) logger, enabling central and visual tracking of DI events, errors, and diagnostics in both UI and console. |
+
+---
 
 ## Contributing
 
 Contributions are welcome! Please open issues or submit pull requests on [GitHub](https://github.com/pese-git/cherrypick).
 
+---
+
 ## License
 
 Licensed under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
@@ -688,6 +730,8 @@ Licensed under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-
 
 **Important:** Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for specific language governing permissions and limitations under the License.
 
+---
+
 ## Links
 
 - [GitHub Repository](https://github.com/pese-git/cherrypick)

cherrypick/example/bin/main.dart

@@ -47,19 +47,19 @@ class FeatureModule extends Module {
 
 Future<void> main() async {
   try {
-  final scope = CherryPick.openRootScope().installModules([AppModule()]);
+    final scope = CherryPick.openRootScope().installModules([AppModule()]);
 
     final subScope = scope
         .openSubScope("featureScope")
         .installModules([FeatureModule(isMock: true)]);
 
-  // Asynchronous instance resolution
+    // Asynchronous instance resolution
-  final dataBloc = await subScope.resolveAsync<DataBloc>();
+    final dataBloc = await subScope.resolveAsync<DataBloc>();
-  dataBloc.data.listen(
+    dataBloc.data.listen(
-    (d) => print('Received data: $d'),
+      (d) => print('Received data: $d'),
-    onError: (e) => print('Error: $e'),
+      onError: (e) => print('Error: $e'),
-    onDone: () => print('DONE'),
+      onDone: () => print('DONE'),
-  );
+    );
 
     await dataBloc.fetchData();
   } catch (e) {

cherrypick/example/cherrypick_helper_example.dart

@@ -36,18 +36,16 @@ class DatabaseModule extends Module {
 class ApiModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<ApiService>().toProvide(() => ApiService(
+    bind<ApiService>()
-      currentScope.resolve<DatabaseService>()
+        .toProvide(() => ApiService(currentScope.resolve<DatabaseService>()));
-    ));
   }
 }
 
 class UserModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<UserService>().toProvide(() => UserService(
+    bind<UserService>()
-      currentScope.resolve<ApiService>()
+        .toProvide(() => UserService(currentScope.resolve<ApiService>()));
-    ));
   }
 }
 
@@ -65,18 +63,16 @@ class CircularServiceB {
 class CircularModuleA extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<CircularServiceA>().toProvide(() => CircularServiceA(
+    bind<CircularServiceA>().toProvide(
-      currentScope.resolve<CircularServiceB>()
+        () => CircularServiceA(currentScope.resolve<CircularServiceB>()));
-    ));
   }
 }
 
 class CircularModuleB extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<CircularServiceB>().toProvide(() => CircularServiceB(
+    bind<CircularServiceB>().toProvide(
-      currentScope.resolve<CircularServiceA>()
+        () => CircularServiceB(currentScope.resolve<CircularServiceA>()));
-    ));
   }
 }
 
@@ -87,11 +83,13 @@ void main() {
   print('1. Globally enable cycle detection:');
 
   CherryPick.enableGlobalCycleDetection();
-  print('✅ Global cycle detection enabled: ${CherryPick.isGlobalCycleDetectionEnabled}');
+  print(
+      '✅ Global cycle detection enabled: ${CherryPick.isGlobalCycleDetectionEnabled}');
 
   // All new scopes will automatically have cycle detection enabled
   final globalScope = CherryPick.openRootScope();
-  print('✅ Root scope has cycle detection enabled: ${globalScope.isCycleDetectionEnabled}');
+  print(
+      '✅ Root scope has cycle detection enabled: ${globalScope.isCycleDetectionEnabled}');
 
   // Install modules without circular dependencies
   globalScope.installModules([
@@ -112,7 +110,8 @@ void main() {
 
   // Создаем безопасный скоуп (с автоматически включенным обнаружением)
   final safeScope = CherryPick.openSafeRootScope();
-  print('✅ Safe scope created with cycle detection: ${safeScope.isCycleDetectionEnabled}');
+  print(
+      '✅ Safe scope created with cycle detection: ${safeScope.isCycleDetectionEnabled}');
 
   safeScope.installModules([
     DatabaseModule(),
@@ -153,30 +152,37 @@ void main() {
   // Создаем скоуп без обнаружения
   // ignore: unused_local_variable
   final specificScope = CherryPick.openRootScope();
-  print('   Detection in root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
+  print(
+      '   Detection in root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
 
   // Включаем обнаружение для конкретного скоупа
   CherryPick.enableCycleDetectionForScope();
-  print('✅ Detection enabled for root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
+  print(
+      '✅ Detection enabled for root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
 
   // Создаем дочерний скоуп
   // ignore: unused_local_variable
   final featureScope = CherryPick.openScope(scopeName: 'feature.auth');
-  print('   Detection in feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
+  print(
+      '   Detection in feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
 
   // Включаем обнаружение для дочернего скоупа
   CherryPick.enableCycleDetectionForScope(scopeName: 'feature.auth');
-  print('✅ Detection enabled for feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
+  print(
+      '✅ Detection enabled for feature.auth scope: ${CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.auth')}');
   print('');
 
   // Example 5: Creating safe child scopes
   print('5. Creating safe child scopes:');
 
-  final safeFeatureScope = CherryPick.openSafeScope(scopeName: 'feature.payments');
+  final safeFeatureScope =
-  print('✅ Safe feature scope created: ${safeFeatureScope.isCycleDetectionEnabled}');
+      CherryPick.openSafeScope(scopeName: 'feature.payments');
+  print(
+      '✅ Safe feature scope created: ${safeFeatureScope.isCycleDetectionEnabled}');
 
   // You can create a complex hierarchy of scopes
-  final complexScope = CherryPick.openSafeScope(scopeName: 'app.feature.auth.login');
+  final complexScope =
+      CherryPick.openSafeScope(scopeName: 'app.feature.auth.login');
   print('✅ Complex scope created: ${complexScope.isCycleDetectionEnabled}');
   print('');
 
@@ -209,7 +215,8 @@ void main() {
   print('');
 
   print('🚀 Production mode:');
-  print('   CherryPick.disableGlobalCycleDetection(); // Disable for performance');
+  print(
+      '   CherryPick.disableGlobalCycleDetection(); // Disable for performance');
   print('   final scope = CherryPick.openRootScope(); // Regular scope');
   print('');
 
@@ -219,7 +226,8 @@ void main() {
   print('');
 
   print('🎯 Feature-specific:');
-  print('   CherryPick.enableCycleDetectionForScope(scopeName: "feature.critical");');
+  print(
+      '   CherryPick.enableCycleDetectionForScope(scopeName: "feature.critical");');
   print('   // Enable only for critical features');
 
   // Cleanup

cherrypick/example/cherrypick_logger_demo.dart

@@ -15,7 +15,7 @@ class AppModule extends Module {
 
 void main() {
   // Set a global logger for the DI system
-  CherryPick.setGlobalLogger(PrintLogger());
+  CherryPick.setGlobalObserver(PrintCherryPickObserver());
 
   // Open the root scope
   final rootScope = CherryPick.openRootScope();
@@ -32,6 +32,6 @@ void main() {
   subScope.closeSubScope('feature.profile');
 
   // Demonstrate disabling and re-enabling logging
-  CherryPick.setGlobalLogger(const SilentLogger());
+  CherryPick.setGlobalObserver(SilentCherryPickObserver());
   rootScope.resolve<UserRepository>(); // now without logs
 }

cherrypick/example/cycle_detection_example.dart

@@ -29,18 +29,16 @@ class OrderService {
 class UserModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<UserService>().toProvide(() => UserService(
+    bind<UserService>()
-      currentScope.resolve<OrderService>()
+        .toProvide(() => UserService(currentScope.resolve<OrderService>()));
-    ));
   }
 }
 
 class OrderModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<OrderService>().toProvide(() => OrderService(
+    bind<OrderService>()
-      currentScope.resolve<UserService>()
+        .toProvide(() => OrderService(currentScope.resolve<UserService>()));
-    ));
   }
 }
 
@@ -103,9 +101,8 @@ class ImprovedUserModule extends Module {
   @override
   void builder(Scope currentScope) {
     bind<UserRepository>().singleton().toProvide(() => UserRepository());
-    bind<ImprovedUserService>().toProvide(() => ImprovedUserService(
+    bind<ImprovedUserService>().toProvide(
-      currentScope.resolve<UserRepository>()
+        () => ImprovedUserService(currentScope.resolve<UserRepository>()));
-    ));
   }
 }
 
@@ -114,9 +111,8 @@ class ImprovedOrderModule extends Module {
   void builder(Scope currentScope) {
     bind<OrderRepository>().singleton().toProvide(() => OrderRepository());
     bind<ImprovedOrderService>().toProvide(() => ImprovedOrderService(
-      currentScope.resolve<OrderRepository>(),
+        currentScope.resolve<OrderRepository>(),
-      currentScope.resolve<ImprovedUserService>()
+        currentScope.resolve<ImprovedUserService>()));
-    ));
   }
 }
 
@@ -127,7 +123,8 @@ void main() {
   print('1. Attempt to create a scope with circular dependencies:');
   try {
     final scope = CherryPick.openRootScope();
-    scope.enableCycleDetection(); // Включаем обнаружение циклических зависимостей
+    scope
+        .enableCycleDetection(); // Включаем обнаружение циклических зависимостей
 
     scope.installModules([
       UserModule(),
@@ -184,7 +181,6 @@ void main() {
     orderService.createOrder('ORD-001', 'John');
     final orders = orderService.getOrdersForUser('John');
     print('✅ Orders for user John: $orders');
-    
   } catch (e) {
     print('❌ Error: $e');
   }

cherrypick/lib/cherrypick.dart

@@ -20,5 +20,5 @@ export 'package:cherrypick/src/global_cycle_detector.dart';
 export 'package:cherrypick/src/helper.dart';
 export 'package:cherrypick/src/module.dart';
 export 'package:cherrypick/src/scope.dart';
-export 'package:cherrypick/src/logger.dart';
 export 'package:cherrypick/src/disposable.dart';
+export 'package:cherrypick/src/observer.dart';

cherrypick/lib/src/binding_resolver.dart

@@ -13,41 +13,70 @@
 
 import 'dart:async';
 
+/// Represents a direct instance or an async instance ([T] or [Future<T>]).
+/// Used for both direct and async bindings.
+///
+/// Example:
+/// ```dart
+/// Instance<String> sync = "hello";
+/// Instance<MyApi> async = Future.value(MyApi());
+/// ```
 typedef Instance<T> = FutureOr<T>;
 
-/// RU: Синхронный или асинхронный провайдер без параметров, возвращающий [T] или [Future<T>].
+/// Provider function type for synchronous or asynchronous, parameterless creation of [T].
-/// ENG: Synchronous or asynchronous provider without parameters, returning [T] or [Future<T>].
+/// Can return [T] or [Future<T>].
+///
+/// Example:
+/// ```dart
+/// Provider<MyService> provider = () => MyService();
+/// Provider<Api> asyncProvider = () async => await Api.connect();
+/// ```
 typedef Provider<T> = FutureOr<T> Function();
 
-/// RU: Провайдер с динамическим параметром, возвращающий [T] или [Future<T>] в зависимости от реализации.
+/// Provider function type that accepts a dynamic parameter, for factory/parametrized injection.
-/// ENG: Provider with dynamic parameter, returning [T] or [Future<T>] depending on implementation.
+/// Returns [T] or [Future<T>].
+///
+/// Example:
+/// ```dart
+/// ProviderWithParams<User> provider = (params) => User(params["name"]);
+/// ```
 typedef ProviderWithParams<T> = FutureOr<T> Function(dynamic);
 
-/// RU: Абстрактный интерфейс для классов, которые разрешают зависимости типа [T].
+/// Abstract interface for dependency resolvers used by [Binding].
-/// ENG: Abstract interface for classes that resolve dependencies of type [T].
+/// Defines how to resolve instances of type [T].
+///
+/// You usually don't use this directly; it's used internally for advanced/low-level DI.
 abstract class BindingResolver<T> {
-  /// RU: Синхронное разрешение зависимости с параметром [params].
+  /// Synchronously resolves the dependency, optionally taking parameters (for factory cases).
-  /// ENG: Synchronous resolution of the dependency with [params].
+  /// Throws if implementation does not support sync resolution.
   T? resolveSync([dynamic params]);
 
-  /// RU: Асинхронное разрешение зависимости с параметром [params].
+  /// Asynchronously resolves the dependency, optionally taking parameters (for factory cases).
-  /// ENG: Asynchronous resolution of the dependency with [params].
+  /// If instance is already a [Future], returns it directly.
   Future<T>? resolveAsync([dynamic params]);
 
-  /// RU: Помечает текущий резолвер как синглтон — результат будет закеширован.
+  /// Marks this resolver as singleton: instance(s) will be cached and reused inside the scope.
-  /// ENG: Marks this resolver as singleton — result will be cached.
   void toSingleton();
 
+  /// Returns true if this resolver is marked as singleton.
   bool get isSingleton;
 }
 
-/// RU: Резолвер, оборачивающий конкретный экземпляр [T] (или Future<T>), без вызова провайдера.
+/// Concrete resolver for direct instance ([T] or [Future<T>]). No provider is called.
-/// ENG: Resolver that wraps a concrete instance of [T] (or Future<T>), without provider invocation.
+///
+/// Used for [Binding.toInstance].
+/// Supports both sync and async resolution; sync will throw if underlying instance is [Future].
+/// Examples:
+/// ```dart
+/// var resolver = InstanceResolver("hello");
+/// resolver.resolveSync(); // == "hello"
+/// var asyncResolver = InstanceResolver(Future.value(7));
+/// asyncResolver.resolveAsync(); // Future<int>
+/// ```
 class InstanceResolver<T> implements BindingResolver<T> {
   final Instance<T> _instance;
 
-  /// RU: Создаёт резолвер, оборачивающий значение [instance].
+  /// Wraps the given instance (sync or async) in a resolver.
-  /// ENG: Creates a resolver that wraps the given [instance].
   InstanceResolver(this._instance);
 
   @override
@@ -62,7 +91,6 @@ class InstanceResolver<T> implements BindingResolver<T> {
   @override
   Future<T> resolveAsync([_]) {
     if (_instance is Future<T>) return _instance;
-
     return Future.value(_instance);
   }
 
@@ -73,8 +101,23 @@ class InstanceResolver<T> implements BindingResolver<T> {
   bool get isSingleton => true;
 }
 
-/// RU: Резолвер, оборачивающий провайдер, с возможностью синглтон-кеширования.
+/// Resolver for provider functions (sync/async/factory), with optional singleton caching.
-/// ENG: Resolver that wraps a provider, with optional singleton caching.
+/// Used for [Binding.toProvide], [Binding.toProvideWithParams], [Binding.singleton].
+///
+/// Examples:
+/// ```dart
+/// // No param, sync:
+/// var r = ProviderResolver((_) => 5, withParams: false);
+/// r.resolveSync(); // == 5
+/// // With param:
+/// var rp = ProviderResolver((p) => p * 2, withParams: true);
+/// rp.resolveSync(2); // == 4
+/// // Singleton:
+/// r.toSingleton();
+/// // Async:
+/// var ra = ProviderResolver((_) async => await Future.value(10), withParams: false);
+/// await ra.resolveAsync(); // == 10
+/// ```
 class ProviderResolver<T> implements BindingResolver<T> {
   final ProviderWithParams<T> _provider;
   final bool _withParams;
@@ -82,8 +125,7 @@ class ProviderResolver<T> implements BindingResolver<T> {
   FutureOr<T>? _cache;
   bool _singleton = false;
 
-  /// RU: Создаёт резолвер из произвольной функции [raw], поддерживающей ноль или один параметр.
+  /// Creates a resolver from [provider], optionally accepting dynamic params.
-  /// ENG: Creates a resolver from arbitrary function [raw], supporting zero or one parameter.
   ProviderResolver(
     ProviderWithParams<T> provider, {
     required bool withParams,
@@ -93,16 +135,13 @@ class ProviderResolver<T> implements BindingResolver<T> {
   @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.',
     );
@@ -111,14 +150,11 @@ class ProviderResolver<T> implements BindingResolver<T> {
   @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;
   }
 
@@ -130,8 +166,7 @@ class ProviderResolver<T> implements BindingResolver<T> {
   @override
   bool get isSingleton => _singleton;
 
-  /// RU: Проверяет, был ли передан параметр, если провайдер требует его.
+  /// Throws if params required but not supplied.
-  /// ENG: Checks if parameter is passed when the provider expects it.
   void _checkParams(dynamic params) {
     if (_withParams && params == null) {
       throw StateError(

cherrypick/lib/src/cycle_detector.dart

@@ -12,19 +12,22 @@
 //
 
 import 'dart:collection';
-import 'package:cherrypick/src/logger.dart';
+import 'package:cherrypick/src/observer.dart';
-import 'package:cherrypick/src/log_format.dart';
 
-/// RU: Исключение, выбрасываемое при обнаружении циклической зависимости.
+/// Exception thrown when a circular dependency is detected during dependency resolution.
-/// ENG: Exception thrown when a circular dependency is detected.
+///
+/// Contains a [message] and the [dependencyChain] showing the resolution cycle.
+///
+/// Example diagnostic:
+/// ```
+/// CircularDependencyException: Circular dependency detected for A
+/// Dependency chain: A -> B -> C -> A
+/// ```
 class CircularDependencyException implements Exception {
   final String message;
   final List<String> dependencyChain;
 
-  CircularDependencyException(this.message, this.dependencyChain) {
+  CircularDependencyException(this.message, this.dependencyChain);
-    // DEBUG
-    
-  }
 
   @override
   String toString() {
@@ -33,134 +36,164 @@ class CircularDependencyException implements Exception {
   }
 }
 
-/// RU: Детектор циклических зависимостей для CherryPick DI контейнера.
+/// Circular dependency detector for CherryPick DI containers.
-/// ENG: Circular dependency detector for CherryPick DI container.
+///
+/// Tracks dependency resolution chains to detect and prevent infinite recursion caused by cycles.
+/// Whenever a resolve chain re-enters a started dependency, a [CircularDependencyException] is thrown with the full chain.
+///
+/// This class is used internally, but you can interact with it through [CycleDetectionMixin].
+///
+/// Example usage (pseudocode):
+/// ```dart
+/// final detector = CycleDetector(observer: myObserver);
+/// try {
+///   detector.startResolving<A>();
+///   // ... resolving A which depends on B, etc
+///   detector.startResolving<B>();
+///   detector.startResolving<A>(); // BOOM: throws exception
+/// } finally {
+///   detector.finishResolving<B>();
+///   detector.finishResolving<A>();
+/// }
+/// ```
 class CycleDetector {
-  final CherryPickLogger _logger;
+  final CherryPickObserver _observer;
   final Set<String> _resolutionStack = HashSet<String>();
   final List<String> _resolutionHistory = [];
 
-  CycleDetector({required CherryPickLogger logger}): _logger = logger;
+  CycleDetector({required CherryPickObserver observer}) : _observer = observer;
 
-  /// RU: Начинает отслеживание разрешения зависимости.
+  /// Starts tracking dependency resolution for type [T] and optional [named] qualifier.
-  /// ENG: Starts tracking dependency resolution.
   ///
-  /// Throws [CircularDependencyException] if circular dependency is detected.
+  /// Throws [CircularDependencyException] if a cycle is found.
   void startResolving<T>({String? named}) {
     final dependencyKey = _createDependencyKey<T>(named);
-    print('[DEBUG] CycleDetector logger type=${_logger.runtimeType} hash=${_logger.hashCode}');
+    _observer.onDiagnostic(
-    _logger.info(formatLogMessage(
+      'CycleDetector startResolving: $dependencyKey',
-      type: 'CycleDetector',
+      details: {
-      name: dependencyKey.toString(),
+        'event': 'startResolving',
-      params: {'event': 'startResolving', 'stackSize': _resolutionStack.length},
+        'stackSize': _resolutionStack.length,
-      description: 'start resolving',
+      },
-    ));
+    );
     if (_resolutionStack.contains(dependencyKey)) {
-      // Найдена циклическая зависимость
       final cycleStartIndex = _resolutionHistory.indexOf(dependencyKey);
-      final cycle = _resolutionHistory.sublist(cycleStartIndex)..add(dependencyKey);
+      final cycle = _resolutionHistory.sublist(cycleStartIndex)
-      // print removed (trace)
+        ..add(dependencyKey);
-      final msg = formatLogMessage(
+      _observer.onCycleDetected(cycle);
-        type: 'CycleDetector',
+      _observer.onError('Cycle detected for $dependencyKey', null, null);
-        name: dependencyKey.toString(),
-        params: {'chain': cycle.join('->')},
-        description: 'cycle detected',
-      );
-      _logger.error(msg);
       throw CircularDependencyException(
         'Circular dependency detected for $dependencyKey',
         cycle,
       );
     }
-    
     _resolutionStack.add(dependencyKey);
     _resolutionHistory.add(dependencyKey);
   }
 
-  /// RU: Завершает отслеживание разрешения зависимости.
+  /// Stops tracking dependency resolution for type [T] and optional [named] qualifier.
-  /// ENG: Finishes tracking dependency resolution.
+  /// Should always be called after [startResolving], including for errors.
   void finishResolving<T>({String? named}) {
     final dependencyKey = _createDependencyKey<T>(named);
-    _logger.info(formatLogMessage(
+    _observer.onDiagnostic(
-      type: 'CycleDetector',
+      'CycleDetector finishResolving: $dependencyKey',
-      name: dependencyKey.toString(),
+      details: {'event': 'finishResolving'},
-      params: {'event': 'finishResolving'},
+    );
-      description: 'finish resolving',
-    ));
     _resolutionStack.remove(dependencyKey);
-    // Удаляем из истории только если это последний элемент
+    // Only remove from history if it's the last one
     if (_resolutionHistory.isNotEmpty &&
         _resolutionHistory.last == dependencyKey) {
       _resolutionHistory.removeLast();
     }
   }
 
-  /// RU: Очищает все состояние детектора.
+  /// Clears all resolution state and resets the cycle detector.
-  /// ENG: Clears all detector state.
   void clear() {
-    _logger.info(formatLogMessage(
+    _observer.onDiagnostic(
-      type: 'CycleDetector',
+      'CycleDetector clear',
-      params: {'event': 'clear'},
+      details: {
-      description: 'resolution stack cleared',
+        'event': 'clear',
-    ));
+        'description': 'resolution stack cleared',
+      },
+    );
     _resolutionStack.clear();
     _resolutionHistory.clear();
   }
 
-  /// RU: Проверяет, находится ли зависимость в процессе разрешения.
+  /// Returns true if dependency [T] (and [named], if specified) is being resolved right now.
-  /// ENG: Checks if dependency is currently being resolved.
   bool isResolving<T>({String? named}) {
     final dependencyKey = _createDependencyKey<T>(named);
     return _resolutionStack.contains(dependencyKey);
   }
 
-  /// RU: Возвращает текущую цепочку разрешения зависимостей.
+  /// Gets the current dependency resolution chain (for diagnostics or debugging).
-  /// ENG: Returns current dependency resolution chain.
+  List<String> get currentResolutionChain =>
-  List<String> get currentResolutionChain => List.unmodifiable(_resolutionHistory);
+      List.unmodifiable(_resolutionHistory);
 
-  /// RU: Создает уникальный ключ для зависимости.
+  /// Returns a unique string key for type [T] (+name).
-  /// ENG: Creates unique key for dependency.
   String _createDependencyKey<T>(String? named) {
     final typeName = T.toString();
     return named != null ? '$typeName@$named' : typeName;
   }
 }
 
-/// RU: Миксин для добавления поддержки обнаружения циклических зависимостей.
+/// Mixin for adding circular dependency detection support to custom DI containers/classes.
-/// ENG: Mixin for adding circular dependency detection support.
+///
+/// Fields:
+///   - `observer`: must be implemented by your class (used for diagnostics and error reporting)
+///
+/// Example usage:
+/// ```dart
+/// class MyContainer with CycleDetectionMixin {
+///   @override
+///   CherryPickObserver get observer => myObserver;
+/// }
+///
+/// final c = MyContainer();
+/// c.enableCycleDetection();
+/// c.withCycleDetection(String, null, () {
+///   // ... dependency resolution code
+/// });
+/// ```
 mixin CycleDetectionMixin {
   CycleDetector? _cycleDetector;
-  CherryPickLogger get logger;
+  CherryPickObserver get observer;
 
-  /// RU: Включает обнаружение циклических зависимостей.
+  /// Turns on circular dependency detection for this class/container.
-  /// ENG: Enables circular dependency detection.
   void enableCycleDetection() {
-    _cycleDetector = CycleDetector(logger: logger);
+    _cycleDetector = CycleDetector(observer: observer);
-    logger.info(formatLogMessage(
+    observer.onDiagnostic(
-      type: 'CycleDetection',
+      'CycleDetection enabled',
-      params: {'event': 'enable'},
+      details: {
-      description: 'cycle detection enabled',
+        'event': 'enable',
-    ));
+        'description': 'cycle detection enabled',
+      },
+    );
   }
 
-  /// RU: Отключает обнаружение циклических зависимостей.
+  /// Shuts off detection and clears any cycle history for this container.
-  /// ENG: Disables circular dependency detection.
   void disableCycleDetection() {
     _cycleDetector?.clear();
-    logger.info(formatLogMessage(
+    observer.onDiagnostic(
-      type: 'CycleDetection',
+      'CycleDetection disabled',
-      params: {'event': 'disable'},
+      details: {
-      description: 'cycle detection disabled',
+        'event': 'disable',
-    ));
+        'description': 'cycle detection disabled',
+      },
+    );
     _cycleDetector = null;
   }
 
-  /// RU: Проверяет, включено ли обнаружение циклических зависимостей.
+  /// Returns true if detection is currently enabled.
-  /// ENG: Checks if circular dependency detection is enabled.
   bool get isCycleDetectionEnabled => _cycleDetector != null;
 
-  /// RU: Выполняет действие с отслеживанием циклических зависимостей.
+  /// Executes [action] while tracking for circular DI cycles for [dependencyType] and [named].
-  /// ENG: Executes action with circular dependency tracking.
+  ///
+  /// Throws [CircularDependencyException] if a dependency cycle is detected.
+  ///
+  /// Example:
+  /// ```dart
+  /// withCycleDetection(String, 'api', () => resolveApi());
+  /// ```
   T withCycleDetection<T>(
     Type dependencyType,
     String? named,
@@ -175,15 +208,12 @@ mixin CycleDetectionMixin {
         : dependencyType.toString();
 
     if (_cycleDetector!._resolutionStack.contains(dependencyKey)) {
-      final cycleStartIndex = _cycleDetector!._resolutionHistory.indexOf(dependencyKey);
+      final cycleStartIndex =
+          _cycleDetector!._resolutionHistory.indexOf(dependencyKey);
       final cycle = _cycleDetector!._resolutionHistory.sublist(cycleStartIndex)
         ..add(dependencyKey);
-      logger.error(formatLogMessage(
+      observer.onCycleDetected(cycle);
-        type: 'CycleDetector',
+      observer.onError('Cycle detected for $dependencyKey', null, null);
-        name: dependencyKey.toString(),
-        params: {'chain': cycle.join('->')},
-        description: 'cycle detected',
-      ));
       throw CircularDependencyException(
         'Circular dependency detected for $dependencyKey',
         cycle,
@@ -204,8 +234,7 @@ mixin CycleDetectionMixin {
     }
   }
 
-  /// RU: Возвращает текущую цепочку разрешения зависимостей.
+  /// Gets the current active dependency resolution chain.
-  /// ENG: Returns current dependency resolution chain.
   List<String> get currentResolutionChain =>
       _cycleDetector?.currentResolutionChain ?? [];
 }

cherrypick/lib/src/factory.dart

@@ -12,6 +12,28 @@
 //
 import 'package:cherrypick/src/scope.dart';
 
+/// Abstract factory interface for creating objects of type [T] using a [Scope].
+///
+/// Can be implemented for advanced dependency injection scenarios where
+/// the resolution requires contextual information from the DI [Scope].
+///
+/// Often used to supply complex objects, runtime-bound services,
+/// or objects depending on dynamic configuration.
+///
+/// Example usage:
+/// ```dart
+/// class MyServiceFactory implements Factory<MyService> {
+///   @override
+///   MyService createInstance(Scope scope) {
+///     final db = scope.resolve<Database>(named: "main");
+///     return MyService(db);
+///   }
+/// }
+///
+/// // Usage in a module:
+/// bind<MyService>().toProvide(() => MyServiceFactory().createInstance(scope));
+/// ```
 abstract class Factory<T> {
+  /// Implement this to provide an instance of [T], with access to the resolving [scope].
   T createInstance(Scope scope);
 }

cherrypick/lib/src/global_cycle_detector.dart

@@ -13,36 +13,51 @@
 
 import 'dart:collection';
 import 'package:cherrypick/cherrypick.dart';
-import 'package:cherrypick/src/log_format.dart';
 
-
+/// GlobalCycleDetector detects and prevents circular dependencies across an entire DI scope hierarchy.
-/// RU: Глобальный детектор циклических зависимостей для всей иерархии скоупов.
+///
-/// ENG: Global circular dependency detector for entire scope hierarchy.
+/// This is particularly important for modular/feature-based applications
+/// where subscopes can introduce indirect cycles that span different scopes.
+///
+/// The detector tracks resolution chains and throws [CircularDependencyException]
+/// when a cycle is found, showing the full chain (including scope context).
+///
+/// Example usage via [GlobalCycleDetectionMixin]:
+/// ```dart
+/// class MyScope with GlobalCycleDetectionMixin { /* ... */ }
+///
+/// final scope = MyScope();
+/// scope.setScopeId('feature');
+/// scope.enableGlobalCycleDetection();
+///
+/// scope.withGlobalCycleDetection(String, null, () {
+///   // ... resolve dependencies here, will detect cross-scope cycles
+/// });
+/// ```
 class GlobalCycleDetector {
   static GlobalCycleDetector? _instance;
 
-  final CherryPickLogger _logger;
+  final CherryPickObserver _observer;
 
-  // Глобальный стек разрешения зависимостей
+  // Global set and chain history for all resolutions
   final Set<String> _globalResolutionStack = HashSet<String>();
-  
-  // История разрешения для построения цепочки зависимостей
   final List<String> _globalResolutionHistory = [];
 
-  // Карта активных детекторов по скоупам
+  // Map of active detectors for subscopes (rarely used directly)
-  final Map<String, CycleDetector> _scopeDetectors = HashMap<String, CycleDetector>();
+  final Map<String, CycleDetector> _scopeDetectors =
+      HashMap<String, CycleDetector>();
 
-  GlobalCycleDetector._internal({required CherryPickLogger logger}): _logger = logger;
+  GlobalCycleDetector._internal({required CherryPickObserver observer})
+      : _observer = observer;
 
-  /// RU: Получить единственный экземпляр глобального детектора.
+  /// Returns the singleton global detector instance, initializing it if needed.
-  /// ENG: Get singleton instance of global detector.
   static GlobalCycleDetector get instance {
-    _instance ??= GlobalCycleDetector._internal(logger:  CherryPick.globalLogger);
+    _instance ??=
+        GlobalCycleDetector._internal(observer: CherryPick.globalObserver);
     return _instance!;
   }
 
-  /// RU: Сбросить глобальный детектор (полезно для тестов).
+  /// Reset internal state (useful for testing).
-  /// ENG: Reset global detector (useful for tests).
   static void reset() {
     _instance?._globalResolutionStack.clear();
     _instance?._globalResolutionHistory.clear();
@@ -50,21 +65,18 @@ class GlobalCycleDetector {
     _instance = null;
   }
 
-  /// RU: Начать отслеживание разрешения зависимости в глобальном контексте.
+  /// Start tracking resolution of dependency [T] with optional [named] and [scopeId].
-  /// ENG: Start tracking dependency resolution in global context.
+  /// Throws [CircularDependencyException] on cycle.
   void startGlobalResolving<T>({String? named, String? scopeId}) {
     final dependencyKey = _createDependencyKeyFromType(T, named, scopeId);
 
     if (_globalResolutionStack.contains(dependencyKey)) {
-      // Найдена глобальная циклическая зависимость
       final cycleStartIndex = _globalResolutionHistory.indexOf(dependencyKey);
-      final cycle = _globalResolutionHistory.sublist(cycleStartIndex)..add(dependencyKey);
+      final cycle = _globalResolutionHistory.sublist(cycleStartIndex)
-      _logger.error(formatLogMessage(
+        ..add(dependencyKey);
-        type: 'CycleDetector',
+      _observer.onCycleDetected(cycle, scopeName: scopeId);
-        name: dependencyKey.toString(),
+      _observer.onError(
-        params: {'chain': cycle.join('->')},
+          'Global circular dependency detected for $dependencyKey', null, null);
-        description: 'cycle detected',
-      ));
       throw CircularDependencyException(
         'Global circular dependency detected for $dependencyKey',
         cycle,
@@ -75,39 +87,35 @@ class GlobalCycleDetector {
     _globalResolutionHistory.add(dependencyKey);
   }
 
-  /// RU: Завершить отслеживание разрешения зависимости в глобальном контексте.
+  /// Finish tracking a dependency. Should always be called after [startGlobalResolving].
-  /// ENG: Finish tracking dependency resolution in global context.
   void finishGlobalResolving<T>({String? named, String? scopeId}) {
     final dependencyKey = _createDependencyKeyFromType(T, named, scopeId);
     _globalResolutionStack.remove(dependencyKey);
 
-    // Удаляем из истории только если это последний элемент
     if (_globalResolutionHistory.isNotEmpty &&
         _globalResolutionHistory.last == dependencyKey) {
       _globalResolutionHistory.removeLast();
     }
   }
 
-  /// RU: Выполнить действие с глобальным отслеживанием циклических зависимостей.
+  /// Internally execute [action] with global cycle detection for [dependencyType], [named], [scopeId].
-  /// ENG: Execute action with global circular dependency tracking.
+  /// Throws [CircularDependencyException] on cycle.
   T withGlobalCycleDetection<T>(
     Type dependencyType,
     String? named,
     String? scopeId,
     T Function() action,
   ) {
-    final dependencyKey = _createDependencyKeyFromType(dependencyType, named, scopeId);
+    final dependencyKey =
+        _createDependencyKeyFromType(dependencyType, named, scopeId);
 
     if (_globalResolutionStack.contains(dependencyKey)) {
       final cycleStartIndex = _globalResolutionHistory.indexOf(dependencyKey);
       final cycle = _globalResolutionHistory.sublist(cycleStartIndex)
         ..add(dependencyKey);
-      _logger.error(formatLogMessage(
+      _observer.onCycleDetected(cycle, scopeName: scopeId);
-        type: 'CycleDetector',
+      _observer.onError(
-        name: dependencyKey.toString(),
+          'Global circular dependency detected for $dependencyKey', null, null);
-        params: {'chain': cycle.join('->')},
-        description: 'cycle detected',
-      ));
       throw CircularDependencyException(
         'Global circular dependency detected for $dependencyKey',
         cycle,
@@ -128,31 +136,28 @@ class GlobalCycleDetector {
     }
   }
 
-  /// RU: Получить детектор для конкретного скоупа.
+  /// Get per-scope detector (not usually needed by consumers).
-  /// ENG: Get detector for specific scope.
   CycleDetector getScopeDetector(String scopeId) {
-    return _scopeDetectors.putIfAbsent(scopeId, () => CycleDetector(logger: CherryPick.globalLogger));
+    return _scopeDetectors.putIfAbsent(
+        scopeId, () => CycleDetector(observer: CherryPick.globalObserver));
   }
 
-  /// RU: Удалить детектор для скоупа.
+  /// Remove detector for a given scope.
-  /// ENG: Remove detector for scope.
   void removeScopeDetector(String scopeId) {
     _scopeDetectors.remove(scopeId);
   }
 
-  /// RU: Проверить, находится ли зависимость в процессе глобального разрешения.
+  /// Returns true if dependency [T] is currently being resolved in the global scope.
-  /// ENG: Check if dependency is currently being resolved globally.
   bool isGloballyResolving<T>({String? named, String? scopeId}) {
     final dependencyKey = _createDependencyKeyFromType(T, named, scopeId);
     return _globalResolutionStack.contains(dependencyKey);
   }
 
-  /// RU: Получить текущую глобальную цепочку разрешения зависимостей.
+  /// Get current global dependency resolution chain (for debugging or diagnostics).
-  /// ENG: Get current global dependency resolution chain.
+  List<String> get globalResolutionChain =>
-  List<String> get globalResolutionChain => List.unmodifiable(_globalResolutionHistory);
+      List.unmodifiable(_globalResolutionHistory);
 
-  /// RU: Очистить все состояние детектора.
+  /// Clears all global and per-scope state in this detector.
-  /// ENG: Clear all detector state.
   void clear() {
     _globalResolutionStack.clear();
     _globalResolutionHistory.clear();
@@ -162,15 +167,9 @@ class GlobalCycleDetector {
 
   void _detectorClear(detector) => detector.clear();
 
-  /// RU: Создать уникальный ключ для зависимости с учетом скоупа.
+  /// Creates a unique dependency key string including scope and name (for diagnostics/cycle checks).
-  /// ENG: Create unique key for dependency including scope.
+  String _createDependencyKeyFromType(
-  //String _createDependencyKey<T>(String? named, String? scopeId) {
+      Type type, String? named, String? scopeId) {
-  //  return _createDependencyKeyFromType(T, named, scopeId);
-  //}
-
-  /// RU: Создать уникальный ключ для зависимости по типу с учетом скоупа.
-  /// ENG: Create unique key for dependency by type including scope.
-  String _createDependencyKeyFromType(Type type, String? named, String? scopeId) {
     final typeName = type.toString();
     final namePrefix = named != null ? '@$named' : '';
     final scopePrefix = scopeId != null ? '[$scopeId]' : '';
@@ -178,40 +177,53 @@ class GlobalCycleDetector {
   }
 }
 
-/// RU: Улучшенный миксин для глобального обнаружения циклических зависимостей.
+/// Enhanced mixin for global circular dependency detection, to be mixed into
-/// ENG: Enhanced mixin for global circular dependency detection.
+/// DI scopes or containers that want cross-scope protection.
+///
+/// Typical usage pattern:
+/// ```dart
+/// class MySubscope with GlobalCycleDetectionMixin { ... }
+///
+/// final scope = MySubscope();
+/// scope.setScopeId('user_profile');
+/// scope.enableGlobalCycleDetection();
+///
+/// scope.withGlobalCycleDetection(UserService, null, () {
+///   // ... resolve user service and friends, auto-detects global cycles
+/// });
+/// ```
 mixin GlobalCycleDetectionMixin {
   String? _scopeId;
   bool _globalCycleDetectionEnabled = false;
 
-  /// RU: Установить идентификатор скоупа для глобального отслеживания.
+  /// Set the scope's unique identifier for global tracking (should be called at scope initialization).
-  /// ENG: Set scope identifier for global tracking.
   void setScopeId(String scopeId) {
     _scopeId = scopeId;
   }
 
-  /// RU: Получить идентификатор скоупа.
+  /// Get the scope's id, if configured.
-  /// ENG: Get scope identifier.
   String? get scopeId => _scopeId;
 
-  /// RU: Включить глобальное обнаружение циклических зависимостей.
+  /// Enable global cross-scope circular dependency detection.
-  /// ENG: Enable global circular dependency detection.
   void enableGlobalCycleDetection() {
     _globalCycleDetectionEnabled = true;
   }
 
-  /// RU: Отключить глобальное обнаружение циклических зависимостей.
+  /// Disable global cycle detection (no cycle checks will be performed globally).
-  /// ENG: Disable global circular dependency detection.
   void disableGlobalCycleDetection() {
     _globalCycleDetectionEnabled = false;
   }
 
-  /// RU: Проверить, включено ли глобальное обнаружение циклических зависимостей.
+  /// Returns true if global cycle detection is currently enabled for this scope/container.
-  /// ENG: Check if global circular dependency detection is enabled.
   bool get isGlobalCycleDetectionEnabled => _globalCycleDetectionEnabled;
 
-  /// RU: Выполнить действие с глобальным отслеживанием циклических зависимостей.
+  /// Executes [action] with global cycle detection for [dependencyType] and [named].
-  /// ENG: Execute action with global circular dependency tracking.
+  /// Throws [CircularDependencyException] if a cycle is detected.
+  ///
+  /// Example:
+  /// ```dart
+  /// withGlobalCycleDetection(UserService, null, () => resolveUser());
+  /// ```
   T withGlobalCycleDetection<T>(
     Type dependencyType,
     String? named,
@@ -229,8 +241,7 @@ mixin GlobalCycleDetectionMixin {
     );
   }
 
-  /// RU: Получить текущую глобальную цепочку разрешения зависимостей.
+  /// Access the current global dependency resolution chain for diagnostics.
-  /// ENG: Get current global dependency resolution chain.
   List<String> get globalResolutionChain =>
       GlobalCycleDetector.instance.globalResolutionChain;
 }

cherrypick/lib/src/helper.dart

@@ -13,16 +13,15 @@
 
 import 'package:cherrypick/src/scope.dart';
 import 'package:cherrypick/src/global_cycle_detector.dart';
-import 'package:cherrypick/src/logger.dart';
+import 'package:cherrypick/src/observer.dart';
 import 'package:meta/meta.dart';
 
-
 Scope? _rootScope;
 
 /// Global logger for all [Scope]s managed by [CherryPick].
 ///
 /// Defaults to [SilentLogger] unless set via [setGlobalLogger].
-CherryPickLogger _globalLogger = const SilentLogger();
+CherryPickObserver _globalObserver = SilentCherryPickObserver();
 
 /// Whether global local-cycle detection is enabled for all Scopes ([Scope.enableCycleDetection]).
 bool _globalCycleDetectionEnabled = false;
@@ -59,12 +58,12 @@ class CherryPick {
   /// ```dart
   /// CherryPick.setGlobalLogger(DefaultLogger());
   /// ```
-  static void setGlobalLogger(CherryPickLogger logger) {
+  static void setGlobalObserver(CherryPickObserver observer) {
-    _globalLogger = logger;
+    _globalObserver = observer;
   }
 
   /// Returns the current global logger used by CherryPick.
-  static CherryPickLogger get globalLogger => _globalLogger;
+  static CherryPickObserver get globalObserver => _globalObserver;
 
   /// Returns the singleton root [Scope], creating it if needed.
   ///
@@ -75,12 +74,13 @@ class CherryPick {
   /// final root = CherryPick.openRootScope();
   /// ```
   static Scope openRootScope() {
-    _rootScope ??= Scope(null, logger: _globalLogger);
+    _rootScope ??= Scope(null, observer: _globalObserver);
     // Apply cycle detection settings
     if (_globalCycleDetectionEnabled && !_rootScope!.isCycleDetectionEnabled) {
       _rootScope!.enableCycleDetection();
     }
-    if (_globalCrossScopeCycleDetectionEnabled && !_rootScope!.isGlobalCycleDetectionEnabled) {
+    if (_globalCrossScopeCycleDetectionEnabled &&
+        !_rootScope!.isGlobalCycleDetectionEnabled) {
       _rootScope!.enableGlobalCycleDetection();
     }
     return _rootScope!;
@@ -96,7 +96,8 @@ class CherryPick {
   /// ```
   static Future<void> closeRootScope() async {
     if (_rootScope != null) {
-      await _rootScope!.dispose(); // Автоматический вызов dispose для rootScope!
+      await _rootScope!
+          .dispose(); // Автоматический вызов dispose для rootScope!
       _rootScope = null;
     }
   }
@@ -141,13 +142,15 @@ class CherryPick {
   /// ```dart
   /// CherryPick.enableCycleDetectionForScope(scopeName: 'api.feature');
   /// ```
-  static void enableCycleDetectionForScope({String scopeName = '', String separator = '.'}) {
+  static void enableCycleDetectionForScope(
+      {String scopeName = '', String separator = '.'}) {
     final scope = _getScope(scopeName, separator);
     scope.enableCycleDetection();
   }
 
   /// Disables cycle detection for a given scope. See [enableCycleDetectionForScope].
-  static void disableCycleDetectionForScope({String scopeName = '', String separator = '.'}) {
+  static void disableCycleDetectionForScope(
+      {String scopeName = '', String separator = '.'}) {
     final scope = _getScope(scopeName, separator);
     scope.disableCycleDetection();
   }
@@ -158,7 +161,8 @@ class CherryPick {
   /// ```dart
   /// CherryPick.isCycleDetectionEnabledForScope(scopeName: 'feature.api');
   /// ```
-  static bool isCycleDetectionEnabledForScope({String scopeName = '', String separator = '.'}) {
+  static bool isCycleDetectionEnabledForScope(
+      {String scopeName = '', String separator = '.'}) {
     final scope = _getScope(scopeName, separator);
     return scope.isCycleDetectionEnabled;
   }
@@ -171,7 +175,8 @@ class CherryPick {
   /// ```dart
   /// print(CherryPick.getCurrentResolutionChain(scopeName: 'feature.api'));
   /// ```
-  static List<String> getCurrentResolutionChain({String scopeName = '', String separator = '.'}) {
+  static List<String> getCurrentResolutionChain(
+      {String scopeName = '', String separator = '.'}) {
     final scope = _getScope(scopeName, separator);
     return scope.currentResolutionChain;
   }
@@ -229,14 +234,13 @@ class CherryPick {
     if (nameParts.isEmpty) {
       throw Exception('Can not open sub scope because scopeName can not split');
     }
-    final scope = nameParts.fold(
+    final scope = nameParts.fold(openRootScope(),
-      openRootScope(),
+        (Scope previous, String element) => previous.openSubScope(element));
-      (Scope previous, String element) => previous.openSubScope(element)
-    );
     if (_globalCycleDetectionEnabled && !scope.isCycleDetectionEnabled) {
       scope.enableCycleDetection();
     }
-    if (_globalCrossScopeCycleDetectionEnabled && !scope.isGlobalCycleDetectionEnabled) {
+    if (_globalCrossScopeCycleDetectionEnabled &&
+        !scope.isGlobalCycleDetectionEnabled) {
       scope.enableGlobalCycleDetection();
     }
     return scope;
@@ -252,21 +256,21 @@ class CherryPick {
   /// CherryPick.closeScope(scopeName: 'network.super.api');
   /// ```
   @experimental
-  static Future<void> closeScope({String scopeName = '', String separator = '.'}) async {
+  static Future<void> closeScope(
+      {String scopeName = '', String separator = '.'}) async {
     if (scopeName.isEmpty) {
       await closeRootScope();
       return;
     }
     final nameParts = scopeName.split(separator);
     if (nameParts.isEmpty) {
-      throw Exception('Can not close sub scope because scopeName can not split');
+      throw Exception(
+          'Can not close sub scope because scopeName can not split');
     }
     if (nameParts.length > 1) {
       final lastPart = nameParts.removeLast();
-      final scope = nameParts.fold(
+      final scope = nameParts.fold(openRootScope(),
-        openRootScope(),
+          (Scope previous, String element) => previous.openSubScope(element));
-        (Scope previous, String element) => previous.openSubScope(element)
-      );
       await scope.closeSubScope(lastPart);
     } else {
       await openRootScope().closeSubScope(nameParts.first);
@@ -316,7 +320,8 @@ class CherryPick {
   ///   print('Global cross-scope detection is ON');
   /// }
   /// ```
-  static bool get isGlobalCrossScopeCycleDetectionEnabled => _globalCrossScopeCycleDetectionEnabled;
+  static bool get isGlobalCrossScopeCycleDetectionEnabled =>
+      _globalCrossScopeCycleDetectionEnabled;
 
   /// Returns the current global dependency resolution chain (across all scopes).
   ///
@@ -367,7 +372,8 @@ class CherryPick {
   /// ```dart
   /// final featureScope = CherryPick.openGlobalSafeScope(scopeName: 'featureA.api');
   /// ```
-  static Scope openGlobalSafeScope({String scopeName = '', String separator = '.'}) {
+  static Scope openGlobalSafeScope(
+      {String scopeName = '', String separator = '.'}) {
     final scope = openScope(scopeName: scopeName, separator: separator);
     scope.enableCycleDetection();
     scope.enableGlobalCycleDetection();

cherrypick/lib/src/log_format.dart

@@ -1,55 +0,0 @@
-//
-// Copyright 2021 Sergey Penkovsky (sergey.penkovsky@gmail.com)
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//      https://www.apache.org/licenses/LICENSE-2.0
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-
-/// Formats a log message string for CherryPick's logging system.
-///
-/// This function provides a unified structure for framework logs (info, warn, error, debug, etc.),
-/// making it easier to parse and analyze events related to DI operations such as resolving bindings,
-/// scope creation, module installation, etc.
-///
-/// All parameters except [name] and [params] are required.
-///
-/// Example:
-/// ```dart
-/// final msg = formatLogMessage(
-///   type: 'Binding',
-///   name: 'MyService',
-///   params: {'parent': 'AppModule', 'lifecycle': 'singleton'},
-///   description: 'created',
-/// );
-/// // Result: [Binding:MyService] parent=AppModule lifecycle=singleton created
-/// ```
-///
-/// Parameters:
-/// - [type]: The type of the log event subject (e.g., 'Binding', 'Scope', 'Module'). Required.
-/// - [name]: Optional name of the subject (binding/scope/module) to disambiguate multiple instances/objects.
-/// - [params]: Optional map for additional context (e.g., id, parent, lifecycle, named, etc.).
-/// - [description]: Concise description of the event. Required.
-///
-/// Returns a structured string:
-///   [type(:name)] param1=val1 param2=val2 ... description
-String formatLogMessage({
-  required String type,        // Binding, Scope, Module, ...
-  String? name,               // Имя binding/scope/module
-  Map<String, Object?>? params, // Дополнительные параметры (id, parent, named и др.)
-  required String description,   // Краткое описание события
-}) {
-  final label = name != null ? '$type:$name' : type;
-  final paramsStr = (params != null && params.isNotEmpty)
-      ? params.entries.map((e) => '${e.key}=${e.value}').join(' ')
-      : '';
-  return '[$label]'
-         '${paramsStr.isNotEmpty ? ' $paramsStr' : ''}'
-         ' $description';
-}

cherrypick/lib/src/logger.dart

@@ -1,108 +0,0 @@
-//
-// Copyright 2021 Sergey Penkovsky (sergey.penkovsky@gmail.com)
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//      https://www.apache.org/licenses/LICENSE-2.0
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-/// ----------------------------------------------------------------------------
-/// CherryPickLogger — интерфейс для логирования событий DI в CherryPick.
-///
-/// ENGLISH:
-/// Interface for dependency injection (DI) logger in CherryPick. Allows you to
-/// receive information about the internal events and errors in the DI system.
-/// Your implementation can use any logging framework or UI.
-///
-/// RUSSIAN:
-/// Интерфейс логгера для DI-контейнера CherryPick. Позволяет получать
-/// сообщения о работе DI-контейнера, его ошибках и событиях, и
-/// интегрировать любые готовые решения для логирования/сбора ошибок.
-/// ----------------------------------------------------------------------------
-abstract class CherryPickLogger {
-  /// ----------------------------------------------------------------------------
-  /// info — Информационное сообщение.
-  ///
-  /// ENGLISH:
-  /// Logs an informational message about DI operation or state.
-  ///
-  /// RUSSIAN:
-  /// Логирование информационного сообщения о событиях DI.
-  /// ----------------------------------------------------------------------------
-  void info(String message);
-
-  /// ----------------------------------------------------------------------------
-  /// warn — Предупреждение.
-  ///
-  /// ENGLISH:
-  /// Logs a warning related to DI events (for example, possible misconfiguration).
-  ///
-  /// RUSSIAN:
-  /// Логирование предупреждения, связанного с DI (например, возможная ошибка
-  /// конфигурации).
-  /// ----------------------------------------------------------------------------
-  void warn(String message);
-
-  /// ----------------------------------------------------------------------------
-  /// error — Ошибка.
-  ///
-  /// ENGLISH:
-  /// Logs an error message, may include error object and stack trace.
-  ///
-  /// RUSSIAN:
-  /// Логирование ошибки, дополнительно может содержать объект ошибки
-  /// и StackTrace.
-  /// ----------------------------------------------------------------------------
-  void error(String message, [Object? error, StackTrace? stackTrace]);
-}
-
-/// ----------------------------------------------------------------------------
-/// SilentLogger — «тихий» логгер CherryPick. Сообщения игнорируются.
-///
-/// ENGLISH:
-/// SilentLogger ignores all log messages. Used by default in production to
-/// avoid polluting logs with DI events.
-///
-/// RUSSIAN:
-/// SilentLogger игнорирует все события логгирования. Используется по умолчанию
-/// на production, чтобы не засорять логи техническими сообщениями DI.
-/// ----------------------------------------------------------------------------
-class SilentLogger implements CherryPickLogger {
-  const SilentLogger();
-  @override
-  void info(String message) {}
-  @override
-  void warn(String message) {}
-  @override
-  void error(String message, [Object? error, StackTrace? stackTrace]) {}
-}
-
-/// ----------------------------------------------------------------------------
-/// PrintLogger — логгер CherryPick, выводящий все сообщения через print.
-///
-/// ENGLISH:
-/// PrintLogger outputs all log messages to the console using `print()`.
-/// Suitable for debugging, prototyping, or simple console applications.
-///
-/// RUSSIAN:
-/// PrintLogger выводит все сообщения (info, warn, error) в консоль через print.
-/// Удобен для отладки или консольных приложений.
-/// ----------------------------------------------------------------------------
-class PrintLogger implements CherryPickLogger {
-  const PrintLogger();
-  @override
-  void info(String message) => print('[info][CherryPick] $message');
-  @override
-  void warn(String message) => print('[warn][CherryPick] $message');
-  @override
-  void error(String message, [Object? error, StackTrace? stackTrace]) {
-    print('[error][CherryPick] $message');
-    if (error != null) print('  error: $error');
-    if (stackTrace != null) print('  stack: $stackTrace');
-  }
-}

cherrypick/lib/src/module.dart

@@ -15,39 +15,71 @@ import 'dart:collection';
 import 'package:cherrypick/src/binding.dart';
 import 'package:cherrypick/src/scope.dart';
 
-/// RU: Класс Module является основой для пользовательских модулей.
+/// Represents a DI module—a reusable group of dependency bindings.
-///  Этот класс нужен для инициализации [Scope].
 ///
-/// RU: The Module class is the basis for custom modules.
+/// Extend [Module] to declaratively group related [Binding] definitions,
-/// This class is needed to initialize [Scope].
+/// then install your module(s) into a [Scope] for dependency resolution.
+///
+/// Modules make it easier to organize your DI configuration for features, layers,
+/// infrastructure, or integration, and support modular app architecture.
+///
+/// Usage example:
+/// ```dart
+/// class AppModule extends Module {
+///   @override
+///   void builder(Scope currentScope) {
+///     bind<NetworkService>().toProvide(() => NetworkService());
+///     bind<AuthService>().toProvide(() => AuthService(currentScope.resolve<NetworkService>()));
+///     bind<Config>().toInstance(Config.dev());
+///   }
+/// }
+///
+/// // Installing the module into the root DI scope:
+/// final rootScope = CherryPick.openRootScope();
+/// rootScope.installModules([AppModule()]);
+/// ```
+///
+/// Combine several modules and submodules to implement scalable architectures.
 ///
 abstract class Module {
   final Set<Binding> _bindingSet = HashSet();
 
-  /// RU: Метод добавляет в коллекцию модуля [Binding] экземпляр.
+  /// Begins the declaration of a new binding within this module.
   ///
-  /// ENG: The method adds an instance to the collection of the [Binding] module.
+  /// Typically used within [builder] to register all needed dependency bindings.
   ///
-  /// return [Binding<T>]
+  /// Example:
+  /// ```dart
+  /// bind<Api>().toProvide(() => MockApi());
+  /// bind<Config>().toInstance(Config.dev());
+  /// ```
   Binding<T> bind<T>() {
     final binding = Binding<T>();
     _bindingSet.add(binding);
     return binding;
   }
 
-  /// RU: Метод возвращает коллекцию [Binding] экземпляров.
+  /// Returns the set of all [Binding] instances registered in this module.
   ///
-  /// ENG: The method returns a collection of [Binding] instances.
+  /// This is typically used internally by [Scope] during module installation,
-  ///
+  /// but can also be used for diagnostics or introspection.
-  /// return [Set<Binding>]
   Set<Binding> get bindingSet => _bindingSet;
 
-  /// RU: Абстрактный метод для инициализации пользовательских экземпляров.
+  /// Abstract method where all dependency bindings are registered.
-  /// В этом методе осуществляется конфигурация зависимостей.
   ///
-  /// ENG: Abstract method for initializing custom instances.
+  /// Override this method in your custom module subclass to declare
-  /// This method configures dependencies.
+  /// all dependency bindings to be provided by this module.
   ///
-  /// return [void]
+  /// The provided [currentScope] can be used for resolving other dependencies,
+  /// accessing configuration, or controlling binding behavior dynamically.
+  ///
+  /// Example (with dependency chaining):
+  /// ```dart
+  /// @override
+  /// void builder(Scope currentScope) {
+  ///   bind<ApiClient>().toProvide(() => RestApi());
+  ///   bind<UserRepo>().toProvide(() => UserRepo(currentScope.resolve<ApiClient>()));
+  /// }
+  /// ```
   void builder(Scope currentScope);
 }

cherrypick/lib/src/observer.dart

@@ -0,0 +1,244 @@
+//
+// Copyright 2021 Sergey Penkovsky (sergey.penkovsky@gmail.com)
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//      https://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+/// An abstract Observer for CherryPick DI container events.
+///
+/// Extend this class to react to and log various events inside the CherryPick Dependency Injection container.
+/// Allows monitoring of registration, creation, disposal, module changes, cache hits/misses, cycles, and
+/// errors/warnings for improved diagnostics and debugging.
+///
+/// All methods have detailed event information, including name, type, scope, and other arguments.
+///
+/// Example: Logging and debugging container events
+/// ```dart
+/// final CherryPickObserver observer = PrintCherryPickObserver();
+/// // Pass observer to CherryPick during setup
+/// CherryPick.openRootScope(observer: observer);
+/// ```
+abstract class CherryPickObserver {
+  // === Registration and instance lifecycle ===
+  /// Called when a binding is registered within the container (new dependency mapping).
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onBindingRegistered('MyService', MyService, scopeName: 'root');
+  /// ```
+  void onBindingRegistered(String name, Type type, {String? scopeName});
+
+  /// Called when an instance is requested (before it is created or retrieved from cache).
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onInstanceRequested('MyService', MyService, scopeName: 'root');
+  /// ```
+  void onInstanceRequested(String name, Type type, {String? scopeName});
+
+  /// Called when a new instance is successfully created.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onInstanceCreated('MyService', MyService, instance, scopeName: 'root');
+  /// ```
+  void onInstanceCreated(String name, Type type, Object instance,
+      {String? scopeName});
+
+  /// Called when an instance is disposed (removed from cache and/or finalized).
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onInstanceDisposed('MyService', MyService, instance, scopeName: 'root');
+  /// ```
+  void onInstanceDisposed(String name, Type type, Object instance,
+      {String? scopeName});
+
+  // === Module events ===
+  /// Called when modules are installed into the container.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onModulesInstalled(['NetworkModule', 'RepositoryModule'], scopeName: 'root');
+  /// ```
+  void onModulesInstalled(List<String> moduleNames, {String? scopeName});
+
+  /// Called when modules are removed from the container.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onModulesRemoved(['RepositoryModule'], scopeName: 'root');
+  /// ```
+  void onModulesRemoved(List<String> moduleNames, {String? scopeName});
+
+  // === Scope lifecycle ===
+  /// Called when a new DI scope is opened (for example, starting a new feature or screen).
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onScopeOpened('user-session');
+  /// ```
+  void onScopeOpened(String name);
+
+  /// Called when an existing DI scope is closed.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onScopeClosed('user-session');
+  /// ```
+  void onScopeClosed(String name);
+
+  // === Cycle detection ===
+  /// Called if a dependency cycle is detected during resolution.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onCycleDetected(['A', 'B', 'C', 'A'], scopeName: 'root');
+  /// ```
+  void onCycleDetected(List<String> chain, {String? scopeName});
+
+  // === Cache events ===
+  /// Called when an instance is found in the cache.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onCacheHit('MyService', MyService, scopeName: 'root');
+  /// ```
+  void onCacheHit(String name, Type type, {String? scopeName});
+
+  /// Called when an instance is not found in the cache and should be created.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onCacheMiss('MyService', MyService, scopeName: 'root');
+  /// ```
+  void onCacheMiss(String name, Type type, {String? scopeName});
+
+  // === Diagnostic ===
+  /// Used for custom diagnostic and debug messages.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onDiagnostic('Cache cleared', details: detailsObj);
+  /// ```
+  void onDiagnostic(String message, {Object? details});
+
+  // === Warnings & errors ===
+  /// Called on non-fatal, recoverable DI container warnings.
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onWarning('Binding override', details: {...});
+  /// ```
+  void onWarning(String message, {Object? details});
+
+  /// Called on error (typically exceptions thrown during resolution, instantiation, or disposal).
+  ///
+  /// Example:
+  /// ```dart
+  /// observer.onError('Failed to resolve dependency', errorObj, stackTraceObj);
+  /// ```
+  void onError(String message, Object? error, StackTrace? stackTrace);
+}
+
+/// Diagnostic/Debug observer that prints all events
+class PrintCherryPickObserver implements CherryPickObserver {
+  @override
+  void onBindingRegistered(String name, Type type, {String? scopeName}) =>
+      print('[binding][CherryPick] $name — $type (scope: $scopeName)');
+
+  @override
+  void onInstanceRequested(String name, Type type, {String? scopeName}) =>
+      print('[request][CherryPick] $name — $type (scope: $scopeName)');
+
+  @override
+  void onInstanceCreated(String name, Type type, Object instance,
+          {String? scopeName}) =>
+      print(
+          '[create][CherryPick] $name — $type => $instance (scope: $scopeName)');
+
+  @override
+  void onInstanceDisposed(String name, Type type, Object instance,
+          {String? scopeName}) =>
+      print(
+          '[dispose][CherryPick] $name — $type => $instance (scope: $scopeName)');
+
+  @override
+  void onModulesInstalled(List<String> modules, {String? scopeName}) => print(
+      '[modules installed][CherryPick] ${modules.join(', ')} (scope: $scopeName)');
+  @override
+  void onModulesRemoved(List<String> modules, {String? scopeName}) => print(
+      '[modules removed][CherryPick] ${modules.join(', ')} (scope: $scopeName)');
+
+  @override
+  void onScopeOpened(String name) => print('[scope opened][CherryPick] $name');
+
+  @override
+  void onScopeClosed(String name) => print('[scope closed][CherryPick] $name');
+
+  @override
+  void onCycleDetected(List<String> chain, {String? scopeName}) => print(
+      '[cycle][CherryPick] Detected: ${chain.join(' -> ')}${scopeName != null ? ' (scope: $scopeName)' : ''}');
+
+  @override
+  void onCacheHit(String name, Type type, {String? scopeName}) =>
+      print('[cache hit][CherryPick] $name — $type (scope: $scopeName)');
+  @override
+  void onCacheMiss(String name, Type type, {String? scopeName}) =>
+      print('[cache miss][CherryPick] $name — $type (scope: $scopeName)');
+
+  @override
+  void onDiagnostic(String message, {Object? details}) =>
+      print('[diagnostic][CherryPick] $message ${details ?? ''}');
+
+  @override
+  void onWarning(String message, {Object? details}) =>
+      print('[warn][CherryPick] $message ${details ?? ''}');
+  @override
+  void onError(String message, Object? error, StackTrace? stackTrace) {
+    print('[error][CherryPick] $message');
+    if (error != null) print('  error: $error');
+    if (stackTrace != null) print('  stack: $stackTrace');
+  }
+}
+
+/// Silent observer: ignores all events
+class SilentCherryPickObserver implements CherryPickObserver {
+  @override
+  void onBindingRegistered(String name, Type type, {String? scopeName}) {}
+  @override
+  void onInstanceRequested(String name, Type type, {String? scopeName}) {}
+  @override
+  void onInstanceCreated(String name, Type type, Object instance,
+      {String? scopeName}) {}
+  @override
+  void onInstanceDisposed(String name, Type type, Object instance,
+      {String? scopeName}) {}
+  @override
+  void onModulesInstalled(List<String> modules, {String? scopeName}) {}
+  @override
+  void onModulesRemoved(List<String> modules, {String? scopeName}) {}
+  @override
+  void onScopeOpened(String name) {}
+  @override
+  void onScopeClosed(String name) {}
+  @override
+  void onCycleDetected(List<String> chain, {String? scopeName}) {}
+  @override
+  void onCacheHit(String name, Type type, {String? scopeName}) {}
+  @override
+  void onCacheMiss(String name, Type type, {String? scopeName}) {}
+  @override
+  void onDiagnostic(String message, {Object? details}) {}
+  @override
+  void onWarning(String message, {Object? details}) {}
+  @override
+  void onError(String message, Object? error, StackTrace? stackTrace) {}
+}

cherrypick/lib/src/scope.dart

@@ -18,39 +18,69 @@ import 'package:cherrypick/src/disposable.dart';
 import 'package:cherrypick/src/global_cycle_detector.dart';
 import 'package:cherrypick/src/binding_resolver.dart';
 import 'package:cherrypick/src/module.dart';
-import 'package:cherrypick/src/logger.dart';
+import 'package:cherrypick/src/observer.dart';
-import 'package:cherrypick/src/log_format.dart';
+// import 'package:cherrypick/src/log_format.dart';
 
+/// Represents a DI scope (container) for modules, subscopes,
+/// and dependency resolution (sync/async) in CherryPick.
+///
+/// Scopes provide hierarchical DI: you can resolve dependencies from parents,
+/// override or isolate modules, and manage scope-specific singletons.
+///
+/// Each scope:
+/// - Can install modules ([installModules]) that define [Binding]s
+/// - Supports parent-child scope tree (see [openSubScope])
+/// - Can resolve dependencies synchronously ([resolve]) or asynchronously ([resolveAsync])
+/// - Cleans up resources for [Disposable] objects (see [dispose])
+/// - Detects dependency cycles (local and global, if enabled)
+///
+/// Example usage:
+/// ```dart
+/// final rootScope = CherryPick.openRootScope();
+/// rootScope.installModules([AppModule()]);
+///
+/// // Synchronous resolution:
+/// final auth = rootScope.resolve<AuthService>();
+///
+/// // Asynchronous resolution:
+/// final db = await rootScope.resolveAsync<Database>();
+///
+/// // Open a child scope (for a feature, page, or test):
+/// final userScope = rootScope.openSubScope('user');
+/// userScope.installModules([UserModule()]);
+///
+/// // Proper resource cleanup (calls dispose() on tracked objects)
+/// await CherryPick.closeRootScope();
+/// ```
 class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
   final Scope? _parentScope;
 
-  late final CherryPickLogger _logger;
+  late final CherryPickObserver _observer;
 
   @override
-  CherryPickLogger get logger => _logger;
+  CherryPickObserver get observer => _observer;
 
   /// COLLECTS all resolved instances that implement [Disposable].
   final Set<Disposable> _disposables = HashSet();
 
-  /// RU: Метод возвращает родительский [Scope].
+  /// Returns the parent [Scope] if present, or null if this is the root scope.
-  ///
-  /// ENG: The method returns the parent [Scope].
-  ///
-  /// return [Scope]
   Scope? get parentScope => _parentScope;
 
   final Map<String, Scope> _scopeMap = HashMap();
 
-  Scope(this._parentScope, {required CherryPickLogger logger}) : _logger = logger {
+  Scope(this._parentScope, {required CherryPickObserver observer})
+      : _observer = observer {
     setScopeId(_generateScopeId());
-    logger.info(formatLogMessage(
+    observer.onScopeOpened(scopeId ?? 'NO_ID');
-      type: 'Scope',
+    observer.onDiagnostic(
-      name: scopeId ?? 'NO_ID',
+      'Scope created: ${scopeId ?? 'NO_ID'}',
-      params: {
+      details: {
+        'type': 'Scope',
+        'name': scopeId ?? 'NO_ID',
         if (_parentScope?.scopeId != null) 'parent': _parentScope!.scopeId,
+        'description': 'scope created',
       },
-      description: 'scope created',
+    );
-    ));
   }
 
   final Set<Module> _modulesList = HashSet();
@@ -58,9 +88,9 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
   // индекс для мгновенного поиска binding’ов
   final Map<Object, Map<String?, BindingResolver>> _bindingResolvers = {};
 
-
+  /// Generates a unique identifier string for this scope instance.
-  /// RU: Генерирует уникальный идентификатор для скоупа.
+  ///
-  /// ENG: Generates unique identifier for scope.
+  /// Used internally for diagnostics, logging and global scope tracking.
   String _generateScopeId() {
     final random = Random();
     final timestamp = DateTime.now().millisecondsSinceEpoch;
@@ -68,16 +98,20 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     return 'scope_${timestamp}_$randomPart';
   }
 
-  /// RU: Метод открывает дочерний (дополнительный) [Scope].
+  /// Opens a named child [Scope] (subscope) as a descendant of the current scope.
   ///
-  /// ENG: The method opens child (additional) [Scope].
+  /// Subscopes inherit modules and DI context from their parent, but can override or extend bindings.
+  /// Useful for feature-isolation, screens, request/transaction lifetimes, and test separation.
   ///
-  /// return [Scope]
+  /// Example:
+  /// ```dart
+  /// final featureScope = rootScope.openSubScope('feature');
+  /// featureScope.installModules([FeatureModule()]);
+  /// final dep = featureScope.resolve<MyDep>();
+  /// ```
   Scope openSubScope(String name) {
     if (!_scopeMap.containsKey(name)) {
-      final childScope = Scope(this, logger: logger); // Наследуем логгер вниз по иерархии
+      final childScope = Scope(this, observer: observer);
-      // print removed (trace)
-      // Наследуем настройки обнаружения циклических зависимостей
       if (isCycleDetectionEnabled) {
         childScope.enableCycleDetection();
       }
@@ -85,65 +119,82 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
         childScope.enableGlobalCycleDetection();
       }
       _scopeMap[name] = childScope;
-      logger.info(formatLogMessage(
+      observer.onDiagnostic(
-        type: 'SubScope',
+        'SubScope created: $name',
-        name: name,
+        details: {
-        params: {
+          'type': 'SubScope',
+          'name': name,
           'id': childScope.scopeId,
           if (scopeId != null) 'parent': scopeId,
+          'description': 'subscope created',
         },
-        description: 'subscope created',
+      );
-      ));
     }
     return _scopeMap[name]!;
   }
 
-  /// RU: Метод закрывает дочерний (дополнительный) [Scope] асинхронно.
+  /// Asynchronously closes and disposes a named child [Scope] (subscope).
   ///
-  /// ENG: The method closes child (additional) [Scope] asynchronously.
+  /// Ensures all [Disposable] objects and internal modules
+  /// in the subscope are properly cleaned up. Also removes any global cycle detectors associated with the subscope.
   ///
-  /// return [Future<void>]
+  /// Example:
+  /// ```dart
+  /// await rootScope.closeSubScope('feature');
+  /// ```
   Future<void> closeSubScope(String name) async {
     final childScope = _scopeMap[name];
     if (childScope != null) {
-      await childScope.dispose(); // асинхронный вызов
+      await childScope.dispose();
-      // Очищаем детектор для дочернего скоупа
       if (childScope.scopeId != null) {
         GlobalCycleDetector.instance.removeScopeDetector(childScope.scopeId!);
       }
-      logger.info(formatLogMessage(
+      observer.onScopeClosed(childScope.scopeId ?? name);
-        type: 'SubScope',
+      observer.onDiagnostic(
-        name: name,
+        'SubScope closed: $name',
-        params: {
+        details: {
+          'type': 'SubScope',
+          'name': name,
           'id': childScope.scopeId,
           if (scopeId != null) 'parent': scopeId,
+          'description': 'subscope closed',
         },
-        description: 'subscope closed',
+      );
-      ));
     }
     _scopeMap.remove(name);
   }
 
-  /// RU: Метод инициализирует пользовательские модули в  [Scope].
+  /// Installs a list of custom [Module]s into the [Scope].
   ///
-  /// ENG: The method initializes custom modules in [Scope].
+  /// Each module registers bindings and configuration for dependencies.
+  /// After calling this, bindings are immediately available for resolve/tryResolve.
   ///
-  /// return [Scope]
+  /// Example:
+  /// ```dart
+  /// rootScope.installModules([AppModule(), NetworkModule()]);
+  /// ```
   Scope installModules(List<Module> modules) {
     _modulesList.addAll(modules);
+    if (modules.isNotEmpty) {
+      observer.onModulesInstalled(
+        modules.map((m) => m.runtimeType.toString()).toList(),
+        scopeName: scopeId,
+      );
+    }
     for (var module in modules) {
-      logger.info(formatLogMessage(
+      observer.onDiagnostic(
-        type: 'Module',
+        'Module installed: ${module.runtimeType}',
-        name: module.runtimeType.toString(),
+        details: {
-        params: {
+          'type': 'Module',
+          'name': module.runtimeType.toString(),
           'scope': scopeId,
+          'description': 'module installed',
         },
-        description: 'module installed',
+      );
-      ));
       module.builder(this);
-      // После builder: для всех новых биндингов
+      // Associate bindings with this scope's observer
       for (final binding in module.bindingSet) {
-        binding.logger = logger;
+        binding.observer = observer;
         binding.logAllDeferred();
       }
     }
@@ -151,49 +202,56 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     return this;
   }
 
-  /// RU: Метод удаляет пользовательские модули из [Scope].
+  /// Removes all installed [Module]s and their bindings from this [Scope].
   ///
-  /// ENG: This method removes custom modules from [Scope].
+  /// Typically used in tests or when resetting app configuration/runtime environment.
+  /// Note: this does not dispose resolved [Disposable]s (call [dispose] for that).
   ///
-  /// return [Scope]
+  /// Example:
+  /// ```dart
+  /// testScope.dropModules();
+  /// ```
   Scope dropModules() {
-    logger.info(formatLogMessage(
+    if (_modulesList.isNotEmpty) {
-      type: 'Scope',
+      observer.onModulesRemoved(
-      name: scopeId,
+        _modulesList.map((m) => m.runtimeType.toString()).toList(),
-      description: 'modules dropped',
+        scopeName: scopeId,
-    ));
+      );
+    }
+    observer.onDiagnostic(
+      'Modules dropped for scope: $scopeId',
+      details: {
+        'type': 'Scope',
+        'name': scopeId,
+        'description': 'modules dropped',
+      },
+    );
     _modulesList.clear();
     _rebuildResolversIndex();
     return this;
   }
 
-  /// RU: Возвращает найденную зависимость, определенную параметром типа [T].
+  /// Resolves a dependency of type [T], optionally by name and with params.
-  /// Выдает [StateError], если зависимость не может быть разрешена.
-  /// Если вы хотите получить [null], если зависимость не может быть найдена,
-  /// то используйте вместо этого [tryResolve]
-  /// return - возвращает объект типа [T]  или [StateError]
   ///
-  /// ENG: Returns the found dependency specified by the type parameter [T].
+  /// Throws [StateError] if the dependency cannot be resolved. (Use [tryResolve] for fallible lookup).
-  /// Throws [StateError] if the dependency cannot be resolved.
+  /// Resolves from installed modules or recurses up the parent scope chain.
-  /// If you want to get [null] if the dependency cannot be found then use [tryResolve] instead
-  /// return - returns an object of type [T] or [StateError]
   ///
+  /// Example:
+  /// ```dart
+  /// final logger = scope.resolve<Logger>();
+  /// final special = scope.resolve<Service>(named: 'special');
+  /// ```
   T resolve<T>({String? named, dynamic params}) {
-    // Используем глобальное отслеживание, если включено
+    observer.onInstanceRequested(T.toString(), T, scopeName: scopeId);
     T result;
     if (isGlobalCycleDetectionEnabled) {
       try {
-        result =  withGlobalCycleDetection<T>(T, named, () {
+        result = withGlobalCycleDetection<T>(T, named, () {
           return _resolveWithLocalDetection<T>(named: named, params: params);
         });
       } catch (e, s) {
-        logger.error(
+        observer.onError(
-          formatLogMessage(
+          'Global cycle detection failed during resolve: $T',
-            type: 'Scope',
-            name: scopeId,
-            params: {'resolve': T.toString()},
-            description: 'global cycle detection failed during resolve',
-          ),
           e,
           s,
         );
@@ -203,13 +261,8 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
       try {
         result = _resolveWithLocalDetection<T>(named: named, params: params);
       } catch (e, s) {
-        logger.error(
+        observer.onError(
-          formatLogMessage(
+          'Failed to resolve: $T',
-            type: 'Scope',
-            name: scopeId,
-            params: {'resolve': T.toString()},
-            description: 'failed to resolve',
-          ),
           e,
           s,
         );
@@ -220,33 +273,31 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     return result;
   }
 
-  /// RU: Разрешение с локальным детектором циклических зависимостей.
+  /// Resolves [T] using the local cycle detector for this scope.
-  /// ENG: Resolution with local circular dependency detector.
+  /// Throws [StateError] if not found or cycle is detected.
+  /// Used internally by [resolve].
   T _resolveWithLocalDetection<T>({String? named, dynamic params}) {
     return withCycleDetection<T>(T, named, () {
       var resolved = _tryResolveInternal<T>(named: named, params: params);
       if (resolved != null) {
-        logger.info(formatLogMessage(
+        observer.onInstanceCreated(T.toString(), T, resolved,
-          type: 'Scope',
+            scopeName: scopeId);
-          name: scopeId,
+        observer.onDiagnostic(
-          params: {
+          'Successfully resolved: $T',
+          details: {
+            'type': 'Scope',
+            'name': scopeId,
             'resolve': T.toString(),
             if (named != null) 'named': named,
+            'description': 'successfully resolved',
           },
-          description: 'successfully resolved',
+        );
-        ));
         return resolved;
       } else {
-        logger.error(
+        observer.onError(
-          formatLogMessage(
+          'Failed to resolve: $T',
-            type: 'Scope',
+          null,
-            name: scopeId,
+          null,
-            params: {
-              'resolve': T.toString(),
-              if (named != null) 'named': named,
-            },
-            description: 'failed to resolve',
-          ),
         );
         throw StateError(
             'Can\'t resolve dependency `$T`. Maybe you forget register it?');
@@ -254,11 +305,16 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     });
   }
 
-  /// RU: Возвращает найденную зависимость типа [T] или null, если она не может быть найдена.
+  /// Attempts to resolve a dependency of type [T], optionally by name and with params.
-  /// ENG: Returns found dependency of type [T] or null if it cannot be found.
   ///
+  /// Returns the resolved dependency, or `null` if not found.
+  /// Does not throw if missing (unlike [resolve]).
+  ///
+  /// Example:
+  /// ```dart
+  /// final maybeDb = scope.tryResolve<Database>();
+  /// ```
   T? tryResolve<T>({String? named, dynamic params}) {
-    // Используем глобальное отслеживание, если включено
     T? result;
     if (isGlobalCycleDetectionEnabled) {
       result = withGlobalCycleDetection<T?>(T, named, () {
@@ -271,8 +327,8 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     return result;
   }
 
-  /// RU: Попытка разрешения с локальным детектором циклических зависимостей.
+  /// Attempts to resolve [T] using the local cycle detector. Returns null if not found or cycle.
-  /// ENG: Try resolution with local circular dependency detector.
+  /// Used internally by [tryResolve].
   T? _tryResolveWithLocalDetection<T>({String? named, dynamic params}) {
     if (isCycleDetectionEnabled) {
       return withCycleDetection<T?>(T, named, () {
@@ -283,72 +339,98 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     }
   }
 
-  /// RU: Внутренний метод для разрешения зависимостей без проверки циклических зависимостей.
+  /// Locates and resolves [T] without cycle detection (direct lookup).
-  /// ENG: Internal method for dependency resolution without circular dependency checking.
+  /// Returns null if not found. Used internally.
   T? _tryResolveInternal<T>({String? named, dynamic params}) {
     final resolver = _findBindingResolver<T>(named);
-
+    // 1 - Try from own modules; 2 - Fallback to parent
-    // 1 Поиск зависимости по всем модулям текущего скоупа
     return resolver?.resolveSync(params) ??
-        // 2 Поиск зависимостей в родительском скоупе
         _parentScope?.tryResolve(named: named, params: params);
   }
 
-  /// RU: Асинхронно возвращает найденную зависимость, определенную параметром типа [T].
+  /// Asynchronously resolves a dependency of type [T].
-  /// Выдает [StateError], если зависимость не может быть разрешена.
-  /// Если хотите получить [null], если зависимость не может быть найдена, используйте [tryResolveAsync].
-  /// return - возвращает объект типа [T] or [StateError]
   ///
-  /// ENG: Asynchronously returns the found dependency specified by the type parameter [T].
+  /// Throws [StateError] if not found. (Use [tryResolveAsync] for a fallible async resolve.)
-  /// Throws [StateError] if the dependency cannot be resolved.
-  /// If you want to get [null] if the dependency cannot be found, use [tryResolveAsync] instead.
-  /// return - returns an object of type [T] or [StateError]
   ///
+  /// Example:
+  /// ```dart
+  /// final db = await scope.resolveAsync<Database>();
+  /// final special = await scope.resolveAsync<Service>(named: "special");
+  /// ```
   Future<T> resolveAsync<T>({String? named, dynamic params}) async {
-    // Используем глобальное отслеживание, если включено
     T result;
     if (isGlobalCycleDetectionEnabled) {
       result = await withGlobalCycleDetection<Future<T>>(T, named, () async {
-        return await _resolveAsyncWithLocalDetection<T>(named: named, params: params);
+        return await _resolveAsyncWithLocalDetection<T>(
+            named: named, params: params);
       });
     } else {
-      result = await _resolveAsyncWithLocalDetection<T>(named: named, params: params);
+      result = await _resolveAsyncWithLocalDetection<T>(
+          named: named, params: params);
     }
     _trackDisposable(result);
     return result;
   }
 
-  /// RU: Асинхронное разрешение с локальным детектором циклических зависимостей.
+  /// Resolves [T] asynchronously using local cycle detector. Throws if not found.
-  /// ENG: Async resolution with local circular dependency detector.
+  /// Internal implementation for async [resolveAsync].
-  Future<T> _resolveAsyncWithLocalDetection<T>({String? named, dynamic params}) async {
+  Future<T> _resolveAsyncWithLocalDetection<T>(
+      {String? named, dynamic params}) async {
     return withCycleDetection<Future<T>>(T, named, () async {
-      var resolved = await _tryResolveAsyncInternal<T>(named: named, params: params);
+      var resolved =
+          await _tryResolveAsyncInternal<T>(named: named, params: params);
       if (resolved != null) {
+        observer.onInstanceCreated(T.toString(), T, resolved,
+            scopeName: scopeId);
+        observer.onDiagnostic(
+          'Successfully async resolved: $T',
+          details: {
+            'type': 'Scope',
+            'name': scopeId,
+            'resolve': T.toString(),
+            if (named != null) 'named': named,
+            'description': 'successfully resolved (async)',
+          },
+        );
         return resolved;
       } else {
+        observer.onError(
+          'Failed to async resolve: $T',
+          null,
+          null,
+        );
         throw StateError(
             'Can\'t resolve async dependency `$T`. Maybe you forget register it?');
       }
     });
   }
 
+  /// Attempts to asynchronously resolve a dependency of type [T].
+  /// Returns the dependency or null if not present (never throws).
+  ///
+  /// Example:
+  /// ```dart
+  /// final user = await scope.tryResolveAsync<User>();
+  /// ```
   Future<T?> tryResolveAsync<T>({String? named, dynamic params}) async {
-    // Используем глобальное отслеживание, если включено
     T? result;
     if (isGlobalCycleDetectionEnabled) {
       result = await withGlobalCycleDetection<Future<T?>>(T, named, () async {
-        return await _tryResolveAsyncWithLocalDetection<T>(named: named, params: params);
+        return await _tryResolveAsyncWithLocalDetection<T>(
+            named: named, params: params);
       });
     } else {
-      result = await _tryResolveAsyncWithLocalDetection<T>(named: named, params: params);
+      result = await _tryResolveAsyncWithLocalDetection<T>(
+          named: named, params: params);
     }
     if (result != null) _trackDisposable(result);
     return result;
   }
 
-  /// RU: Асинхронная попытка разрешения с локальным детектором циклических зависимостей.
+  /// Attempts to resolve [T] asynchronously using local cycle detector. Returns null if missing.
-  /// ENG: Async try resolution with local circular dependency detector.
+  /// Internal implementation for async [tryResolveAsync].
-  Future<T?> _tryResolveAsyncWithLocalDetection<T>({String? named, dynamic params}) async {
+  Future<T?> _tryResolveAsyncWithLocalDetection<T>(
+      {String? named, dynamic params}) async {
     if (isCycleDetectionEnabled) {
       return withCycleDetection<Future<T?>>(T, named, () async {
         return await _tryResolveAsyncInternal<T>(named: named, params: params);
@@ -358,21 +440,22 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     }
   }
 
-  /// RU: Внутренний метод для асинхронного разрешения зависимостей без проверки циклических зависимостей.
+  /// Direct async resolution for [T] without cycle check. Returns null if missing. Internal use only.
-  /// ENG: Internal method for async dependency resolution without circular dependency checking.
+  Future<T?> _tryResolveAsyncInternal<T>(
-  Future<T?> _tryResolveAsyncInternal<T>({String? named, dynamic params}) async {
+      {String? named, dynamic params}) async {
     final resolver = _findBindingResolver<T>(named);
-
+    // 1 - Try from own modules; 2 - Fallback to parent
-    // 1 Поиск зависимости по всем модулям текущего скоупа
     return resolver?.resolveAsync(params) ??
-        // 2 Поиск зависимостей в родительском скоупе
         _parentScope?.tryResolveAsync(named: named, params: params);
   }
 
+  /// Looks up the [BindingResolver] for [T] and [named] within this scope.
+  /// Returns null if none found. Internal use only.
   BindingResolver<T>? _findBindingResolver<T>(String? named) =>
       _bindingResolvers[T]?[named] as BindingResolver<T>?;
 
-  // Индексируем все binding’и после каждого installModules/dropModules
+  /// Rebuilds the internal index of all [BindingResolver]s from installed modules.
+  /// Called after [installModules] and [dropModules]. Internal use only.
   void _rebuildResolversIndex() {
     _bindingResolvers.clear();
     for (var module in _modulesList) {
@@ -384,14 +467,24 @@ class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
     }
   }
 
-  /// INTERNAL: Tracks Disposable objects
+  /// Tracks resolved [Disposable] instances, to ensure dispose is called automatically.
+  /// Internal use only.
   void _trackDisposable(Object? obj) {
     if (obj is Disposable && !_disposables.contains(obj)) {
       _disposables.add(obj);
     }
   }
 
-  /// Calls dispose on all tracked disposables and child scopes recursively (async).
+  /// Asynchronously disposes this [Scope], all tracked [Disposable] objects, and recursively
+  /// all its child subscopes.
+  ///
+  /// This method should always be called when a scope is no longer needed
+  /// to guarantee timely resource cleanup (files, sockets, streams, handles, etc).
+  ///
+  /// Example:
+  /// ```dart
+  /// await myScope.dispose();
+  /// ```
   Future<void> dispose() async {
     // First dispose children scopes
     for (final subScope in _scopeMap.values) {

cherrypick/pubspec.yaml

@@ -1,8 +1,8 @@
 name: cherrypick
 description: Cherrypick is a small dependency injection (DI) library for dart/flutter projects.
-version: 3.0.0-dev.7
+version: 3.0.0-dev.10
-homepage: https://pese-git.github.io/cherrypick-site/
+homepage: https://cherrypick-di.dev/
-documentation: https://github.com/pese-git/cherrypick/wiki
+documentation: https://cherrypick-di.dev/docs/intro
 repository: https://github.com/pese-git/cherrypick
 issue_tracker: https://github.com/pese-git/cherrypick/issues
 topics:

cherrypick/test/logger_integration_test.dart

@@ -12,6 +12,7 @@ class DummyModule extends Module {
 }
 
 class A {}
+
 class B {}
 
 class CyclicModule extends Module {
@@ -23,38 +24,27 @@ class CyclicModule extends Module {
 }
 
 void main() {
-  late MockLogger logger;
+  late MockObserver observer;
 
   setUp(() {
-    logger = MockLogger();
+    observer = MockObserver();
   });
 
-  test('Global logger receives Scope and Binding events', () {
+  test('Global logger receives Binding events', () {
-    final scope = Scope(null, logger: logger);
+    final scope = Scope(null, observer: observer);
     scope.installModules([DummyModule()]);
     final _ = scope.resolve<DummyService>(named: 'test');
 
-    // Новый стиль проверки для formatLogMessage:
+    // Проверяем, что биндинг DummyService зарегистрирован
     expect(
-      logger.infos.any((m) => m.startsWith('[Scope:') && m.contains('created')),
+      observer.bindings.any((m) => m.contains('DummyService')),
-      isTrue,
-    );
-    expect(
-      logger.infos.any((m) => m.startsWith('[Binding:DummyService') && m.contains('created')),
-      isTrue,
-    );
-    expect(
-      logger.infos.any((m) => m.startsWith('[Binding:DummyService') && m.contains('named') && m.contains('name=test')),
-      isTrue,
-    );
-    expect(
-      logger.infos.any((m) => m.startsWith('[Scope:') && m.contains('resolve=DummyService') && m.contains('successfully resolved')),
       isTrue,
     );
+    // Можно добавить проверки diagnostics, если Scope что-то пишет туда
   });
 
   test('CycleDetector logs cycle detection error', () {
-    final scope = Scope(null, logger: logger);
+    final scope = Scope(null, observer: observer);
     // print('[DEBUG] TEST SCOPE logger type=${scope.logger.runtimeType} hash=${scope.logger.hashCode}');
     scope.enableCycleDetection();
     scope.installModules([CyclicModule()]);
@@ -62,12 +52,14 @@ void main() {
       () => scope.resolve<A>(),
       throwsA(isA<CircularDependencyException>()),
     );
-    // Дополнительно ищем и среди info на случай если лог от CycleDetector ошибочно не попал в errors
+    // Проверяем, что цикл зафиксирован либо в errors, либо в diagnostics либо cycles
-    final foundInErrors = logger.errors.any((m) =>
+    final foundInErrors =
-      m.startsWith('[CycleDetector:') && m.contains('cycle detected'));
+        observer.errors.any((m) => m.contains('cycle detected'));
-    final foundInInfos = logger.infos.any((m) =>
+    final foundInDiagnostics =
-      m.startsWith('[CycleDetector:') && m.contains('cycle detected'));
+        observer.diagnostics.any((m) => m.contains('cycle detected'));
-    expect(foundInErrors || foundInInfos, isTrue,
+    final foundCycleNotified = observer.cycles.isNotEmpty;
-      reason: 'Ожидаем хотя бы один лог о цикле на уровне error или info; вот все errors: ${logger.errors}\ninfos: ${logger.infos}');
+    expect(foundInErrors || foundInDiagnostics || foundCycleNotified, isTrue,
+        reason:
+            'Ожидаем хотя бы один лог о цикле! errors: ${observer.errors}\ndiag: ${observer.diagnostics}\ncycles: ${observer.cycles}');
   });
 }

cherrypick/test/mock_logger.dart

@@ -1,16 +1,49 @@
 import 'package:cherrypick/cherrypick.dart';
 
-class MockLogger implements CherryPickLogger {
+class MockObserver implements CherryPickObserver {
-  final List<String> infos = [];
+  final List<String> diagnostics = [];
-  final List<String> warns = [];
+  final List<String> warnings = [];
   final List<String> errors = [];
+  final List<List<String>> cycles = [];
+  final List<String> bindings = [];
 
   @override
-  void info(String message) => infos.add(message);
+  void onDiagnostic(String message, {Object? details}) =>
+      diagnostics.add(message);
+
   @override
-  void warn(String message) => warns.add(message);
+  void onWarning(String message, {Object? details}) => warnings.add(message);
+
   @override
-  void error(String message, [Object? e, StackTrace? s]) =>
+  void onError(String message, Object? error, StackTrace? stackTrace) => errors.add(
-      errors.add(
+      '$message${error != null ? ' $error' : ''}${stackTrace != null ? '\n$stackTrace' : ''}');
-          '$message${e != null ? ' $e' : ''}${s != null ? '\n$s' : ''}');
+
+  @override
+  void onCycleDetected(List<String> chain, {String? scopeName}) =>
+      cycles.add(chain);
+
+  @override
+  void onBindingRegistered(String name, Type type, {String? scopeName}) =>
+      bindings.add('$name $type');
+
+  @override
+  void onInstanceRequested(String name, Type type, {String? scopeName}) {}
+  @override
+  void onInstanceCreated(String name, Type type, Object instance,
+      {String? scopeName}) {}
+  @override
+  void onInstanceDisposed(String name, Type type, Object instance,
+      {String? scopeName}) {}
+  @override
+  void onModulesInstalled(List<String> moduleNames, {String? scopeName}) {}
+  @override
+  void onModulesRemoved(List<String> moduleNames, {String? scopeName}) {}
+  @override
+  void onScopeOpened(String name) {}
+  @override
+  void onScopeClosed(String name) {}
+  @override
+  void onCacheHit(String name, Type type, {String? scopeName}) {}
+  @override
+  void onCacheMiss(String name, Type type, {String? scopeName}) {}
 }

cherrypick/test/src/cross_scope_cycle_test.dart

@@ -46,7 +46,9 @@ void main() {
       );
     });
 
-    test('current implementation limitation - may not detect cross-scope cycles', () {
+    test(
+        'current implementation limitation - may not detect cross-scope cycles',
+        () {
       // Этот тест демонстрирует ограничение текущей реализации
       final parentScope = CherryPick.openRootScope();
       parentScope.enableCycleDetection();

cherrypick/test/src/cycle_detector_test.dart

@@ -4,16 +4,16 @@ import 'package:cherrypick/cherrypick.dart';
 import '../mock_logger.dart';
 
 void main() {
-  late MockLogger logger;
+  late MockObserver observer;
   setUp(() {
-    logger = MockLogger();
+    observer = MockObserver();
-    CherryPick.setGlobalLogger(logger);
+    CherryPick.setGlobalObserver(observer);
   });
   group('CycleDetector', () {
     late CycleDetector detector;
 
     setUp(() {
-      detector = CycleDetector(logger: logger);
+      detector = CycleDetector(observer: observer);
     });
 
     test('should detect simple circular dependency', () {
@@ -50,10 +50,9 @@ void main() {
       expect(
         () => detector.startResolving<String>(),
         throwsA(predicate((e) =>
-          e is CircularDependencyException &&
+            e is CircularDependencyException &&
-          e.dependencyChain.contains('String') &&
+            e.dependencyChain.contains('String') &&
-          e.dependencyChain.length > 1
+            e.dependencyChain.length > 1)),
-        )),
       );
     });
 
@@ -161,14 +160,16 @@ class ServiceB {
 class CircularModuleA extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<ServiceA>().toProvide(() => ServiceA(currentScope.resolve<ServiceB>()));
+    bind<ServiceA>()
+        .toProvide(() => ServiceA(currentScope.resolve<ServiceB>()));
   }
 }
 
 class CircularModuleB extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<ServiceB>().toProvide(() => ServiceB(currentScope.resolve<ServiceA>()));
+    bind<ServiceB>()
+        .toProvide(() => ServiceB(currentScope.resolve<ServiceA>()));
   }
 }
 

cherrypick/test/src/global_cycle_detection_test.dart

@@ -37,7 +37,9 @@ void main() {
         expect(CherryPick.isGlobalCrossScopeCycleDetectionEnabled, isFalse);
       });
 
-      test('should automatically enable global cycle detection for new root scope', () {
+      test(
+          'should automatically enable global cycle detection for new root scope',
+          () {
         CherryPick.enableGlobalCrossScopeCycleDetection();
 
         final scope = CherryPick.openRootScope();
@@ -45,7 +47,9 @@ void main() {
         expect(scope.isGlobalCycleDetectionEnabled, isTrue);
       });
 
-      test('should automatically enable global cycle detection for existing root scope', () {
+      test(
+          'should automatically enable global cycle detection for existing root scope',
+          () {
         final scope = CherryPick.openRootScope();
         expect(scope.isGlobalCycleDetectionEnabled, isFalse);
 
@@ -56,15 +60,18 @@ void main() {
     });
 
     group('Global Safe Scope Creation', () {
-      test('should create global safe root scope with both detections enabled', () {
+      test('should create global safe root scope with both detections enabled',
+          () {
         final scope = CherryPick.openGlobalSafeRootScope();
 
         expect(scope.isCycleDetectionEnabled, isTrue);
         expect(scope.isGlobalCycleDetectionEnabled, isTrue);
       });
 
-      test('should create global safe sub-scope with both detections enabled', () {
+      test('should create global safe sub-scope with both detections enabled',
-        final scope = CherryPick.openGlobalSafeScope(scopeName: 'feature.global');
+          () {
+        final scope =
+            CherryPick.openGlobalSafeScope(scopeName: 'feature.global');
 
         expect(scope.isCycleDetectionEnabled, isTrue);
         expect(scope.isGlobalCycleDetectionEnabled, isTrue);

cherrypick/test/src/helper_cycle_detection_test.dart

@@ -3,10 +3,10 @@ import 'package:test/test.dart';
 import '../mock_logger.dart';
 
 void main() {
-  late MockLogger logger;
+  late MockObserver observer;
   setUp(() {
-    logger = MockLogger();
+    observer = MockObserver();
-    CherryPick.setGlobalLogger(logger);
+    CherryPick.setGlobalObserver(observer);
   });
   group('CherryPick Cycle Detection Helper Methods', () {
     setUp(() {
@@ -39,7 +39,9 @@ void main() {
         expect(CherryPick.isGlobalCycleDetectionEnabled, isFalse);
       });
 
-      test('should automatically enable cycle detection for new root scope when global is enabled', () {
+      test(
+          'should automatically enable cycle detection for new root scope when global is enabled',
+          () {
         CherryPick.enableGlobalCycleDetection();
 
         final scope = CherryPick.openRootScope();
@@ -47,7 +49,9 @@ void main() {
         expect(scope.isCycleDetectionEnabled, isTrue);
       });
 
-      test('should automatically enable cycle detection for existing root scope when global is enabled', () {
+      test(
+          'should automatically enable cycle detection for existing root scope when global is enabled',
+          () {
         final scope = CherryPick.openRootScope();
         expect(scope.isCycleDetectionEnabled, isFalse);
 
@@ -56,7 +60,9 @@ void main() {
         expect(scope.isCycleDetectionEnabled, isTrue);
       });
 
-      test('should automatically disable cycle detection for existing root scope when global is disabled', () {
+      test(
+          'should automatically disable cycle detection for existing root scope when global is disabled',
+          () {
         CherryPick.enableGlobalCycleDetection();
         final scope = CherryPick.openRootScope();
         expect(scope.isCycleDetectionEnabled, isTrue);
@@ -99,21 +105,25 @@ void main() {
         final scopeName = 'feature.auth';
         CherryPick.openScope(scopeName: scopeName);
 
-        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName), isFalse);
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName),
+            isFalse);
 
         CherryPick.enableCycleDetectionForScope(scopeName: scopeName);
 
-        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName), isTrue);
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName),
+            isTrue);
       });
 
       test('should disable cycle detection for specific scope', () {
         final scopeName = 'feature.auth';
         CherryPick.enableCycleDetectionForScope(scopeName: scopeName);
-        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName), isTrue);
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName),
+            isTrue);
 
         CherryPick.disableCycleDetectionForScope(scopeName: scopeName);
 
-        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName), isFalse);
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName),
+            isFalse);
       });
     });
 
@@ -134,14 +144,17 @@ void main() {
         // Глобальная настройка отключена
         expect(CherryPick.isGlobalCycleDetectionEnabled, isFalse);
 
-        final scope = CherryPick.openSafeScope(scopeName: 'feature.independent');
+        final scope =
+            CherryPick.openSafeScope(scopeName: 'feature.independent');
 
         expect(scope.isCycleDetectionEnabled, isTrue);
       });
     });
 
     group('Resolution Chain Tracking', () {
-      test('should return empty resolution chain for scope without cycle detection', () {
+      test(
+          'should return empty resolution chain for scope without cycle detection',
+          () {
         CherryPick.openRootScope();
 
         final chain = CherryPick.getCurrentResolutionChain();
@@ -149,7 +162,9 @@ void main() {
         expect(chain, isEmpty);
       });
 
-      test('should return empty resolution chain for scope with cycle detection but no active resolution', () {
+      test(
+          'should return empty resolution chain for scope with cycle detection but no active resolution',
+          () {
         CherryPick.enableCycleDetectionForScope();
 
         final chain = CherryPick.getCurrentResolutionChain();
@@ -161,14 +176,17 @@ void main() {
         final scopeName = 'feature.tracking';
         CherryPick.enableCycleDetectionForScope(scopeName: scopeName);
 
-        final chain = CherryPick.getCurrentResolutionChain(scopeName: scopeName);
+        final chain =
+            CherryPick.getCurrentResolutionChain(scopeName: scopeName);
 
         expect(chain, isEmpty); // Пустая, так как нет активного разрешения
       });
     });
 
     group('Integration with Circular Dependencies', () {
-      test('should detect circular dependency with global cycle detection enabled', () {
+      test(
+          'should detect circular dependency with global cycle detection enabled',
+          () {
         CherryPick.enableGlobalCycleDetection();
 
         final scope = CherryPick.openRootScope();
@@ -190,14 +208,16 @@ void main() {
         );
       });
 
-      test('should not detect circular dependency when cycle detection is disabled', () {
+      test(
+          'should not detect circular dependency when cycle detection is disabled',
+          () {
         final scope = CherryPick.openRootScope();
         scope.installModules([CircularTestModule()]);
 
         // Без обнаружения циклических зависимостей не будет выброшено CircularDependencyException,
         // но может произойти StackOverflowError при попытке создания объекта
         expect(() => scope.resolve<CircularServiceA>(),
-               throwsA(isA<StackOverflowError>()));
+            throwsA(isA<StackOverflowError>()));
       });
     });
 
@@ -205,7 +225,8 @@ void main() {
       test('should handle empty scope name as root scope', () {
         CherryPick.enableCycleDetectionForScope(scopeName: '');
 
-        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: ''), isTrue);
+        expect(
+            CherryPick.isCycleDetectionEnabledForScope(scopeName: ''), isTrue);
         expect(CherryPick.isCycleDetectionEnabledForScope(), isTrue);
       });
 
@@ -213,14 +234,21 @@ void main() {
         final complexScopeName = 'app.feature.auth.login';
         CherryPick.enableCycleDetectionForScope(scopeName: complexScopeName);
 
-        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: complexScopeName), isTrue);
+        expect(
+            CherryPick.isCycleDetectionEnabledForScope(
+                scopeName: complexScopeName),
+            isTrue);
       });
 
       test('should handle custom separator', () {
         final scopeName = 'app/feature/auth';
-        CherryPick.enableCycleDetectionForScope(scopeName: scopeName, separator: '/');
+        CherryPick.enableCycleDetectionForScope(
+            scopeName: scopeName, separator: '/');
 
-        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName, separator: '/'), isTrue);
+        expect(
+            CherryPick.isCycleDetectionEnabledForScope(
+                scopeName: scopeName, separator: '/'),
+            isTrue);
       });
     });
   });
@@ -240,7 +268,9 @@ class CircularServiceB {
 class CircularTestModule extends Module {
   @override
   void builder(Scope currentScope) {
-    bind<CircularServiceA>().toProvide(() => CircularServiceA(currentScope.resolve<CircularServiceB>()));
+    bind<CircularServiceA>().toProvide(
-    bind<CircularServiceB>().toProvide(() => CircularServiceB(currentScope.resolve<CircularServiceA>()));
+        () => CircularServiceA(currentScope.resolve<CircularServiceB>()));
+    bind<CircularServiceB>().toProvide(
+        () => CircularServiceB(currentScope.resolve<CircularServiceA>()));
   }
 }

cherrypick/test/src/scope_test.dart

@@ -1,4 +1,5 @@
-import 'package:cherrypick/cherrypick.dart' show Disposable, Module, Scope, CherryPick;
+import 'package:cherrypick/cherrypick.dart'
+    show Disposable, Module, Scope, CherryPick;
 import 'dart:async';
 import 'package:test/test.dart';
 import '../mock_logger.dart';
@@ -18,7 +19,9 @@ class AsyncExampleDisposable implements Disposable {
 class AsyncExampleModule extends Module {
   @override
   void builder(Scope scope) {
-    bind<AsyncExampleDisposable>().toProvide(() => AsyncExampleDisposable()).singleton();
+    bind<AsyncExampleDisposable>()
+        .toProvide(() => AsyncExampleDisposable())
+        .singleton();
   }
 }
 
@@ -49,7 +52,9 @@ class CountingDisposable implements Disposable {
 class ModuleCountingDisposable extends Module {
   @override
   void builder(Scope scope) {
-    bind<CountingDisposable>().toProvide(() => CountingDisposable()).singleton();
+    bind<CountingDisposable>()
+        .toProvide(() => CountingDisposable())
+        .singleton();
   }
 }
 
@@ -97,10 +102,9 @@ class AsyncModule extends Module {
     bind<AsyncCreatedDisposable>()
         // ignore: deprecated_member_use_from_same_package
         .toProvideAsync(() async {
-          await Future.delayed(Duration(milliseconds: 10));
+      await Future.delayed(Duration(milliseconds: 10));
-          return AsyncCreatedDisposable();
+      return AsyncCreatedDisposable();
-        })
+    }).singleton();
-        .singleton();
   }
 }
 
@@ -110,18 +114,19 @@ void main() {
   // --------------------------------------------------------------------------
   group('Scope & Subscope Management', () {
     test('Scope has no parent if constructed with null', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger);
+      final scope = Scope(null, observer: observer);
       expect(scope.parentScope, null);
     });
     test('Can open and retrieve the same subScope by key', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger);
+      final scope = Scope(null, observer: observer);
-      expect(Scope(scope, logger: logger), isNotNull); // эквивалент
+      expect(Scope(scope, observer: observer), isNotNull); // эквивалент
     });
-    test('closeSubScope removes subscope so next openSubScope returns new', () async {
+    test('closeSubScope removes subscope so next openSubScope returns new',
-      final logger = MockLogger();
+        () async {
-      final scope = Scope(null, logger: logger);
+      final observer = MockObserver();
+      final scope = Scope(null, observer: observer);
       final subScope = scope.openSubScope("child");
       expect(scope.openSubScope("child"), same(subScope));
       await scope.closeSubScope("child");
@@ -130,9 +135,9 @@ void main() {
     });
 
     test('closeSubScope removes subscope so next openSubScope returns new', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger);
+      final scope = Scope(null, observer: observer);
-      expect(Scope(scope, logger: logger), isNotNull); // эквивалент
+      expect(Scope(scope, observer: observer), isNotNull); // эквивалент
       // Нет необходимости тестировать open/closeSubScope в этом юните
     });
   });
@@ -140,48 +145,49 @@ void main() {
   // --------------------------------------------------------------------------
   group('Dependency Resolution (standard)', () {
     test("Throws StateError if value can't be resolved", () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger);
+      final scope = Scope(null, observer: observer);
       expect(() => scope.resolve<String>(), throwsA(isA<StateError>()));
     });
     test('Resolves value after adding a dependency', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
       final expectedValue = 'test string';
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
           .installModules([TestModule<String>(value: expectedValue)]);
       expect(scope.resolve<String>(), expectedValue);
     });
     test('Returns a value from parent scope', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
       final expectedValue = 5;
-      final parentScope = Scope(null, logger: logger);
+      final parentScope = Scope(null, observer: observer);
-      final scope = Scope(parentScope, logger: logger);
+      final scope = Scope(parentScope, observer: observer);
 
       parentScope.installModules([TestModule<int>(value: expectedValue)]);
       expect(scope.resolve<int>(), expectedValue);
     });
     test('Returns several values from parent container', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
       final expectedIntValue = 5;
       final expectedStringValue = 'Hello world';
-      final parentScope = Scope(null, logger: logger).installModules([
+      final parentScope = Scope(null, observer: observer).installModules([
         TestModule<int>(value: expectedIntValue),
         TestModule<String>(value: expectedStringValue)
       ]);
-      final scope = Scope(parentScope, logger: logger);
+      final scope = Scope(parentScope, observer: observer);
 
       expect(scope.resolve<int>(), expectedIntValue);
       expect(scope.resolve<String>(), expectedStringValue);
     });
     test("Throws StateError if parent hasn't value too", () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final parentScope = Scope(null, logger: logger);
+      final parentScope = Scope(null, observer: observer);
-      final scope = Scope(parentScope, logger: logger);
+      final scope = Scope(parentScope, observer: observer);
       expect(() => scope.resolve<int>(), throwsA(isA<StateError>()));
     });
     test("After dropModules resolves fail", () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)..installModules([TestModule<int>(value: 5)]);
+      final scope = Scope(null, observer: observer)
+        ..installModules([TestModule<int>(value: 5)]);
       expect(scope.resolve<int>(), 5);
       scope.dropModules();
       expect(() => scope.resolve<int>(), throwsA(isA<StateError>()));
@@ -191,8 +197,8 @@ void main() {
   // --------------------------------------------------------------------------
   group('Named Dependencies', () {
     test('Resolve named binding', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
         ..installModules([
           TestModule<String>(value: "first"),
           TestModule<String>(value: "second", name: "special")
@@ -201,8 +207,8 @@ void main() {
       expect(scope.resolve<String>(), "first");
     });
     test('Named binding does not clash with unnamed', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
         ..installModules([
           TestModule<String>(value: "foo", name: "bar"),
         ]);
@@ -210,8 +216,8 @@ void main() {
       expect(scope.resolve<String>(named: "bar"), "foo");
     });
     test("tryResolve returns null for missing named", () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
         ..installModules([
           TestModule<String>(value: "foo"),
         ]);
@@ -222,8 +228,8 @@ void main() {
   // --------------------------------------------------------------------------
   group('Provider with parameters', () {
     test('Resolve dependency using providerWithParams', () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
         ..installModules([
           _InlineModule((m, s) {
             m.bind<int>().toProvideWithParams((param) => (param as int) * 2);
@@ -237,8 +243,8 @@ void main() {
   // --------------------------------------------------------------------------
   group('Async Resolution', () {
     test('Resolve async instance', () async {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
         ..installModules([
           _InlineModule((m, s) {
             m.bind<String>().toInstance(Future.value('async value'));
@@ -247,8 +253,8 @@ void main() {
       expect(await scope.resolveAsync<String>(), "async value");
     });
     test('Resolve async provider', () async {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
         ..installModules([
           _InlineModule((m, s) {
             m.bind<int>().toProvide(() async => 7);
@@ -257,8 +263,8 @@ void main() {
       expect(await scope.resolveAsync<int>(), 7);
     });
     test('Resolve async provider with param', () async {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger)
+      final scope = Scope(null, observer: observer)
         ..installModules([
           _InlineModule((m, s) {
             m.bind<int>().toProvideWithParams((x) async => (x as int) * 3);
@@ -268,8 +274,8 @@ void main() {
       expect(() => scope.resolveAsync<int>(), throwsA(isA<StateError>()));
     });
     test('tryResolveAsync returns null for missing', () async {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger);
+      final scope = Scope(null, observer: observer);
       final result = await scope.tryResolveAsync<String>();
       expect(result, isNull);
     });
@@ -278,8 +284,8 @@ void main() {
   // --------------------------------------------------------------------------
   group('Optional resolution and error handling', () {
     test("tryResolve returns null for missing dependency", () {
-      final logger = MockLogger();
+      final observer = MockObserver();
-      final scope = Scope(null, logger: logger);
+      final scope = Scope(null, observer: observer);
       expect(scope.tryResolve<int>(), isNull);
     });
   });
@@ -294,8 +300,9 @@ void main() {
       await scope.dispose();
       expect(t.disposed, isTrue);
     });
-    test('scope.disposeAsync calls dispose on all unique disposables', () async {
+    test('scope.disposeAsync calls dispose on all unique disposables',
-      final scope = Scope(null, logger: MockLogger());
+        () async {
+      final scope = Scope(null, observer: MockObserver());
       scope.installModules([ModuleWithDisposable()]);
       final t1 = scope.resolve<TestDisposable>();
       final t2 = scope.resolve<AnotherDisposable>();
@@ -305,7 +312,8 @@ void main() {
       expect(t1.disposed, isTrue);
       expect(t2.disposed, isTrue);
     });
-    test('calling disposeAsync twice does not throw and not call twice', () async {
+    test('calling disposeAsync twice does not throw and not call twice',
+        () async {
       final scope = CherryPick.openRootScope();
       scope.installModules([ModuleWithDisposable()]);
       final t = scope.resolve<TestDisposable>();
@@ -313,7 +321,8 @@ void main() {
       await scope.dispose();
       expect(t.disposed, isTrue);
     });
-    test('Non-disposable dependency is ignored by scope.disposeAsync', () async {
+    test('Non-disposable dependency is ignored by scope.disposeAsync',
+        () async {
       final scope = CherryPick.openRootScope();
       scope.installModules([ModuleWithDisposable()]);
       final s = scope.resolve<String>();
@@ -327,7 +336,8 @@ void main() {
   group('Scope/subScope dispose edge cases', () {
     test('Dispose called in closed subScope only', () async {
       final root = CherryPick.openRootScope();
-      final sub = root.openSubScope('feature')..installModules([ModuleCountingDisposable()]);
+      final sub = root.openSubScope('feature')
+        ..installModules([ModuleCountingDisposable()]);
       final d = sub.resolve<CountingDisposable>();
       expect(d.disposeCount, 0);
 
@@ -339,7 +349,8 @@ void main() {
       expect(d.disposeCount, 1);
 
       // Повторное открытие subScope создает NEW instance (dispose на старый не вызовется снова)
-      final sub2 = root.openSubScope('feature')..installModules([ModuleCountingDisposable()]);
+      final sub2 = root.openSubScope('feature')
+        ..installModules([ModuleCountingDisposable()]);
       final d2 = sub2.resolve<CountingDisposable>();
       expect(identical(d, d2), isFalse);
       await root.closeSubScope('feature');
@@ -347,8 +358,14 @@ void main() {
     });
     test('Dispose for all nested subScopes on root disposeAsync', () async {
       final root = CherryPick.openRootScope();
-      root.openSubScope('a').openSubScope('b').installModules([ModuleCountingDisposable()]);
+      root
-      final d = root.openSubScope('a').openSubScope('b').resolve<CountingDisposable>();
+          .openSubScope('a')
+          .openSubScope('b')
+          .installModules([ModuleCountingDisposable()]);
+      final d = root
+          .openSubScope('a')
+          .openSubScope('b')
+          .resolve<CountingDisposable>();
       await root.dispose();
       expect(d.disposeCount, 1);
     });
@@ -357,7 +374,8 @@ void main() {
   // --------------------------------------------------------------------------
   group('Async disposable (Future test)', () {
     test('Async Disposable is awaited on disposeAsync', () async {
-      final scope = CherryPick.openRootScope()..installModules([AsyncExampleModule()]);
+      final scope = CherryPick.openRootScope()
+        ..installModules([AsyncExampleModule()]);
       final d = scope.resolve<AsyncExampleDisposable>();
       expect(d.disposed, false);
       await scope.dispose();

cherrypick_annotations/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.1.2-dev.1
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+## 1.1.2-dev.0
+
+ - **DOCS**(annotations): unify and improve English DartDoc for all DI annotations.
+
 ## 1.1.1
 
  - **FIX**(license): correct urls.

cherrypick_annotations/analysis_options.yaml

@@ -12,6 +12,9 @@
 # The core lints are also what is used by pub.dev for scoring packages.
 
 include: package:lints/recommended.yaml
+analyzer:
+  errors:
+    camel_case_types: ignore
 
 # Uncomment the following section to specify additional rules.
 

cherrypick_annotations/lib/src/inject.dart

@@ -13,22 +13,30 @@
 
 import 'package:meta/meta.dart';
 
-/// Annotation for field injection in CherryPick DI framework.
+/// Marks a field for dependency injection by CherryPick's code generator.
-/// Apply this to a field, and the code generator will automatically inject
-/// the appropriate dependency into it.
 ///
-/// ---
+/// Use `@inject()` on fields within a class marked with `@injectable()`.
+/// Such fields will be automatically injected from the DI [Scope]
+/// when using the generated mixin or calling `.injectFields()`.
 ///
-/// Аннотация для внедрения зависимости в поле через фреймворк CherryPick DI.
+/// Example:
-/// Поместите её на поле класса — генератор кода автоматически подставит нужную зависимость.
-///
-/// Example / Пример:
 /// ```dart
-/// @inject()
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
-/// late final SomeService service;
+///
+/// @injectable()
+/// class LoginScreen with _\$LoginScreen {
+///   @inject()
+///   late final AuthService authService;
+///
+///   @inject()
+///   @named('main')
+///   late final ApiClient api;
+/// }
+///
+/// // After running build_runner, call:
+/// // LoginScreen().injectFields();
 /// ```
 @experimental
-// ignore: camel_case_types
 final class inject {
   const inject();
 }

cherrypick_annotations/lib/src/injectable.dart

@@ -13,26 +13,31 @@
 
 import 'package:meta/meta.dart';
 
-/// Marks a class as injectable for the CherryPick dependency injection framework.
+/// Marks a class as injectable, enabling automatic field injection by CherryPick's code generator.
-/// If a class is annotated with [@injectable()], the code generator will
-/// create a mixin to perform automatic injection of fields marked with [@inject].
 ///
-/// ---
+/// Use `@injectable()` on a class whose fields (marked with `@inject`) you want to be automatically injected from the DI [Scope].
+/// When used together with code generation (see cherrypick_generator), a mixin will be generated to inject fields.
 ///
-/// Помечает класс как внедряемый для фреймворка внедрения зависимостей CherryPick.
+/// Example:
-/// Если класс помечен аннотацией [@injectable()], генератор создаст миксин
-/// для автоматического внедрения полей, отмеченных [@inject].
-///
-/// Example / Пример:
 /// ```dart
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
+///
 /// @injectable()
-/// class MyWidget extends StatelessWidget {
+/// class ProfileScreen with _\$ProfileScreen {
 ///   @inject()
-///   late final MyService service;
+///   late final UserManager manager;
+///
+///   @inject()
+///   @named('main')
+///   late final ApiClient api;
 /// }
+///
+/// // After running build_runner, call:
+/// // profileScreen.injectFields();
 /// ```
+///
+/// After running the generator, the mixin (`_\$ProfileScreen`) will be available to help auto-inject all [@inject] fields in your widget/service/controller.
 @experimental
-// ignore: camel_case_types
 final class injectable {
   const injectable();
 }

cherrypick_annotations/lib/src/instance.dart

@@ -11,58 +11,39 @@
 // limitations under the License.
 //
 
-/// ENGLISH:
+import 'package:meta/meta.dart';
-/// Annotation to specify that a new instance should be provided on each request.
+
+/// Marks a provider method or class to always create a new instance (factory) in CherryPick DI.
 ///
-/// Use the `@instance()` annotation for methods or classes in your DI module
+/// Use `@instance()` to annotate methods or classes in your DI module/class
-/// to declare that the DI container must create a new object every time
+/// when you want a new object to be created on every injection (no singleton caching).
-/// the dependency is injected (i.e., no singleton behavior).
+/// The default DI lifecycle is instance/factory unless otherwise specified.
 ///
-/// Example:
+/// ### Example (in a module method)
 /// ```dart
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
+///
 /// @module()
-/// abstract class AppModule extends Module {
+/// abstract class FeatureModule {
 ///   @instance()
-///   Foo foo() => Foo();
+///   MyService provideService() => MyService();
+///
+///   @singleton()
+///   Logger provideLogger() => Logger();
 /// }
 /// ```
 ///
-/// This will generate:
+/// ### Example (on a class, with @injectable)
 /// ```dart
-/// final class $AppModule extends AppModule {
+/// @injectable()
-///   @override
+/// @instance()
-///   void builder(Scope currentScope) {
+/// class MyFactoryClass {
-///     bind<Foo>().toInstance(() => foo());
+///   // ...
-///   }
 /// }
 /// ```
 ///
-/// RUSSIAN (Русский):
+/// See also: [@singleton]
-/// Аннотация для создания нового экземпляра при каждом запросе.
+@experimental
-///
-/// Используйте `@instance()` для методов или классов в DI-модуле,
-/// чтобы указать, что контейнер внедрения зависимостей должен создавать
-/// новый объект при каждом обращении к зависимости (то есть, не синглтон).
-///
-/// Пример:
-/// ```dart
-/// @module()
-/// abstract class AppModule extends Module {
-///   @instance()
-///   Foo foo() => Foo();
-/// }
-/// ```
-///
-/// Будет сгенерирован следующий код:
-/// ```dart
-/// final class $AppModule extends AppModule {
-///   @override
-///   void builder(Scope currentScope) {
-///     bind<Foo>().toInstance(() => foo());
-///   }
-/// }
-/// ```
-// ignore: camel_case_types
 final class instance {
   const instance();
 }

cherrypick_annotations/lib/src/module.dart

@@ -11,59 +11,40 @@
 // limitations under the License.
 //
 
-/// ENGLISH:
+import 'package:meta/meta.dart';
-/// Annotation for marking Dart classes or libraries as modules.
+
+/// Marks an abstract Dart class as a dependency injection module for CherryPick code generation.
 ///
-/// Use the `@module()` annotation on abstract classes (or on a library)
+/// Use `@module()` on your abstract class to indicate it provides DI bindings (via provider methods).
-/// to indicate that the class represents a DI (Dependency Injection) module.
+/// This enables code generation of a concrete module that registers all bindings from your methods.
-/// This is commonly used in code generation tools to automatically register
-/// and configure dependencies defined within the module.
 ///
-/// Example:
+/// Typical usage:
 /// ```dart
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
+///
 /// @module()
-/// abstract class AppModule extends Module {
+/// abstract class AppModule {
-///   // Dependency definitions go here.
+///   @singleton()
+///   Logger provideLogger() => Logger();
+///
+///   @named('mock')
+///   ApiClient mockApi() => MockApiClient();
 /// }
 /// ```
 ///
-/// Generates code like:
+/// The generated code will look like:
 /// ```dart
 /// final class $AppModule extends AppModule {
 ///   @override
 ///   void builder(Scope currentScope) {
-///     // Dependency registration...
+///     // Dependency registration code...
 ///   }
 /// }
 /// ```
 ///
-/// RUSSIAN (Русский):
+/// See also: [@provide], [@singleton], [@instance], [@named]
-/// Аннотация для пометки классов или библиотек Dart как модуля.
+@experimental
-///
-/// Используйте `@module()` для абстрактных классов (или библиотек), чтобы
-/// показать, что класс реализует DI-модуль (Dependency Injection).
-/// Обычно используется генераторами кода для автоматической регистрации
-/// и конфигурирования зависимостей, определённых в модуле.
-///
-/// Пример:
-/// ```dart
-/// @module()
-/// abstract class AppModule extends Module {
-///   // Определения зависимостей
-/// }
-/// ```
-///
-/// Будет сгенерирован код:
-/// ```dart
-/// final class $AppModule extends AppModule {
-///   @override
-///   void builder(Scope currentScope) {
-///     // Регистрация зависимостей...
-///   }
-/// }
-/// ```
-// ignore: camel_case_types
 final class module {
-  /// Creates a [module] annotation.
+  /// Creates a [module] annotation for use on a DI module class.
   const module();
 }

cherrypick_annotations/lib/src/named.dart

@@ -11,67 +11,52 @@
 // limitations under the License.
 //
 
-/// ENGLISH:
+import 'package:meta/meta.dart';
-/// Annotation to assign a name or identifier to a class, method, or other element.
+
+/// Assigns a name or key identifier to a class, field, factory method or parameter
+/// for use in multi-registration scenarios (named dependencies) in CherryPick DI.
 ///
-/// The `@named('value')` annotation allows you to specify a string name
+/// Use `@named('key')` to distinguish between multiple bindings/implementations
-/// for a dependency, factory, or injectable. This is useful for distinguishing
+/// of the same type—when registering and when injecting dependencies.
-/// between multiple registrations of the same type in dependency injection,
-/// code generation, and for providing human-readable metadata.
 ///
-/// Example:
+/// You can use `@named`:
+/// - On provider/factory methods in a module
+/// - On fields with `@inject()` to receive a named instance
+/// - On function parameters (for method/constructor injection)
+///
+/// ### Example: On Provider Method
 /// ```dart
 /// @module()
-/// abstract class AppModule extends Module {
+/// abstract class AppModule {
-///   @named('dio')
+///   @named('main')
-///   Dio dio() => Dio();
+///   ApiClient apiClient() => ApiClient();
+///
+///   @named('mock')
+///   ApiClient mockApi() => MockApiClient();
 /// }
 /// ```
 ///
-/// This will generate:
+/// ### Example: On Injectable Field
 /// ```dart
-/// final class $AppModule extends AppModule {
+/// @injectable()
-///   @override
+/// class WidgetModel with _\$WidgetModel {
-///   void builder(Scope currentScope) {
+///   @inject()
-///     bind<Dio>().toProvide(() => dio()).withName('dio').singleton();
+///   @named('main')
-///   }
+///   late final ApiClient api;
 /// }
 /// ```
 ///
-/// RUSSIAN (Русский):
+/// ### Example: On Parameter
-/// Аннотация для задания имени или идентификатора классу, методу или другому элементу.
-///
-/// Аннотация `@named('значение')` позволяет указать строковое имя для зависимости,
-/// фабрики или внедряемого значения. Это удобно для различения нескольких
-/// регистраций одного типа в DI, генерации кода.
-///
-/// Пример:
 /// ```dart
-/// @module()
+/// class UserScreen {
-/// abstract class AppModule extends Module {
+///   UserScreen(@named('current') User user);
-///   @named('dio')
-///   Dio dio() => Dio();
 /// }
 /// ```
-///
+@experimental
-/// Будет сгенерирован следующий код:
-/// ```dart
-/// final class $AppModule extends AppModule {
-///   @override
-///   void builder(Scope currentScope) {
-///     bind<Dio>().toProvide(() => dio()).withName('dio').singleton();
-///   }
-/// }
-/// ```
-// ignore: camel_case_types
 final class named {
-  /// EN: The assigned name or identifier for the element.
+  /// The assigned name or identifier for the dependency, provider, or parameter.
-  ///
-  /// RU: Назначенное имя или идентификатор для элемента.
   final String value;
 
-  /// EN: Creates a [named] annotation with the given [value].
+  /// Creates a [named] annotation with the given [value] key or name.
-  ///
-  /// RU: Создаёт аннотацию [named] с заданным значением [value].
   const named(this.value);
 }

cherrypick_annotations/lib/src/params.dart

@@ -11,46 +11,33 @@
 // limitations under the License.
 //
 
-/// ENGLISH:
+import 'package:meta/meta.dart';
-/// Annotation to mark a method parameter for injection with run-time arguments.
+
+/// Marks a parameter in a provider method to receive dynamic runtime arguments when resolving a dependency.
 ///
-/// Use the `@params()` annotation to specify that a particular parameter of a
+/// Use `@params()` in a DI module/factory method when the value must be supplied by the user/code at injection time,
-/// provider method should be assigned a value supplied at resolution time,
+/// not during static wiring (such as user input, navigation arguments, etc).
-/// rather than during static dependency graph creation. This is useful in DI
+///
-/// when a dependency must receive dynamic data passed by the consumer
+/// This enables CherryPick and its codegen to generate .withParams or .toProvideWithParams bindings — so your provider can access runtime values.
-/// (via `.withParams(...)` in the generated code).
 ///
 /// Example:
 /// ```dart
-/// @provide()
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
-/// String greet(@params() dynamic params) => 'Hello $params';
-/// ```
 ///
-/// This will generate:
+/// @module()
+/// abstract class FeatureModule {
+///   @provide
+///   UserManager createManager(@params Map<String, dynamic> runtimeParams) {
+///     return UserManager.forUserId(runtimeParams['userId']);
+///   }
+/// }
+/// ```
+/// Usage at injection/resolution:
 /// ```dart
-/// bind<String>().toProvideWithParams((args) => greet(args));
+/// final manager = scope.resolve<UserManager>(params: {'userId': myId});
 /// ```
-///
+@experimental
-/// RUSSIAN (Русский):
-/// Аннотация для пометки параметра метода, который будет внедряться со значением во время выполнения.
-///
-/// Используйте `@params()` чтобы указать, что конкретный параметр метода-провайдера
-/// должен получать значение, передаваемое в момент обращения к зависимости,
-/// а не на этапе построения графа зависимостей. Это полезно, если зависимость
-/// должна получать данные динамически от пользователя или другого процесса
-/// через `.withParams(...)` в сгенерированном коде.
-///
-/// Пример:
-/// ```dart
-/// @provide()
-/// String greet(@params() dynamic params) => 'Hello $params';
-/// ```
-///
-/// Будет сгенерировано:
-/// ```dart
-/// bind<String>().toProvideWithParams((args) => greet(args));
-/// ```
-// ignore: camel_case_types
 final class params {
+  /// Marks a method/constructor parameter as supplied at runtime by the caller.
   const params();
 }

cherrypick_annotations/lib/src/provide.dart

@@ -11,60 +11,34 @@
 // limitations under the License.
 //
 
-/// ENGLISH:
+import 'package:meta/meta.dart';
-/// Annotation to declare a factory/provider method or class as a singleton.
+
+/// Marks a method or class as a dependency provider (factory/provider) for CherryPick module code generation.
 ///
-/// Use the `@singleton()` annotation on methods in your DI module to specify
+/// Use `@provide` on any method inside a `@module()` annotated class when you want that method
-/// that only one instance of the resulting object should be created and shared
+/// to be used as a DI factory/provider during code generation.
-/// for all consumers. This is especially useful in dependency injection
+///
-/// frameworks and service locators.
+/// This should be used for methods that create dynamic, optional, or complex dependencies, especially
+/// if you want to control the codegen/injection pipeline explicitly and support parameters.
 ///
 /// Example:
 /// ```dart
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
+///
 /// @module()
-/// abstract class AppModule extends Module {
+/// abstract class FeatureModule {
+///   @provide
+///   Future<Api> provideApi(@params Map<String, dynamic> args) async => ...;
+///
 ///   @singleton()
-///   Dio dio() => Dio();
+///   @provide
+///   Logger provideLogger() => Logger();
 /// }
 /// ```
 ///
-/// This generates the following code:
+/// See also: [@singleton], [@instance], [@params], [@named]
-/// ```dart
+@experimental
-/// final class $AppModule extends AppModule {
-///   @override
-///   void builder(Scope currentScope) {
-///     bind<Dio>().toProvide(() => dio()).singleton();
-///   }
-/// }
-/// ```
-///
-/// RUSSIAN (Русский):
-/// Аннотация для объявления фабричного/провайдерного метода или класса синглтоном.
-///
-/// Используйте `@singleton()` для методов внутри DI-модуля, чтобы указать,
-/// что соответствующий объект (экземпляр класса) должен быть создан только один раз
-/// и использоваться всеми компонентами приложения (единый общий экземпляр).
-/// Это характерно для систем внедрения зависимостей и сервис-локаторов.
-///
-/// Пример:
-/// ```dart
-/// @module()
-/// abstract class AppModule extends Module {
-///   @singleton()
-///   Dio dio() => Dio();
-/// }
-/// ```
-///
-/// Будет сгенерирован следующий код:
-/// ```dart
-/// final class $AppModule extends AppModule {
-///   @override
-///   void builder(Scope currentScope) {
-///     bind<Dio>().toProvide(() => dio()).singleton();
-///   }
-/// }
-/// ```
-// ignore: camel_case_types
 final class provide {
+  /// Creates a [provide] annotation.
   const provide();
 }

cherrypick_annotations/lib/src/scope.dart

@@ -13,25 +13,41 @@
 
 import 'package:meta/meta.dart';
 
-/// Annotation to specify a scope for dependency injection in CherryPick.
+/// Specifies the DI scope or region from which a dependency should be resolved.
-/// Use this on an injected field to indicate from which scope
-/// the dependency must be resolved.
 ///
-/// ---
+/// Use `@scope('scopeName')` on an injected field, parameter, or provider method when you want
+/// to resolve a dependency not from the current scope, but from another named scope/subcontainer.
 ///
-/// Аннотация для указания области внедрения (scope) в CherryPick.
+/// Useful for advanced DI scenarios: multi-feature/state isolation, navigation stacks, explicit subscopes, or testing.
-/// Используйте её на инъецируемом поле, чтобы определить из какой области
-/// должна быть получена зависимость.
 ///
-/// Example / Пример:
+/// Example (injected field):
 /// ```dart
-/// @inject()
+/// @injectable()
-/// @scope('profile')
+/// class ProfileScreen with _\$ProfileScreen {
-/// late final ProfileManager profileManager;
+///   @inject()
+///   @scope('profile')
+///   late final ProfileManager manager;
+/// }
+/// ```
+///
+/// Example (parameter):
+/// ```dart
+/// class TabBarModel {
+///   TabBarModel(@scope('tabs') TabContext context);
+/// }
+/// ```
+///
+/// Example (in a module):
+/// ```dart
+/// @module()
+/// abstract class FeatureModule {
+///   @provide
+///   Service service(@scope('shared') SharedConfig config);
+/// }
 /// ```
 @experimental
-// ignore: camel_case_types
 final class scope {
+  /// The name/key of the DI scope from which to resolve this dependency.
   final String? name;
   const scope(this.name);
 }

cherrypick_annotations/lib/src/singleton.dart

@@ -11,63 +11,32 @@
 // limitations under the License.
 //
 
-/// ENGLISH:
+import 'package:meta/meta.dart';
-/// Annotation to declare a dependency as a singleton.
+
+/// Marks a provider method or class so its instance is created only once and shared (singleton) for DI in CherryPick.
 ///
-/// Use the `@singleton()` annotation on provider methods inside a module
+/// Use `@singleton()` on provider methods or classes in your DI module to ensure only one instance is ever created
-/// to indicate that only a single instance of this dependency should be
+/// and reused across the application's lifetime (or scope lifetime).
-/// created and shared throughout the application's lifecycle. This is
-/// typically used in dependency injection frameworks or service locators
-/// to guarantee a single shared instance.
 ///
 /// Example:
 /// ```dart
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
+///
 /// @module()
-/// abstract class AppModule extends Module {
+/// abstract class AppModule {
 ///   @singleton()
-///   Dio dio() => Dio();
+///   ApiClient createApi() => ApiClient();
 /// }
 /// ```
 ///
-/// This will generate code like:
+/// The generated code will ensure:
 /// ```dart
-/// final class $AppModule extends AppModule {
+/// bind<ApiClient>().toProvide(() => createApi()).singleton();
-///   @override
-///   void builder(Scope currentScope) {
-///     bind<Dio>().toProvide(() => dio()).singleton();
-///   }
-/// }
 /// ```
 ///
-/// RUSSIAN (Русский):
+/// See also: [@instance], [@provide], [@named]
-/// Аннотация для объявления зависимости как синглтона.
+@experimental
-///
-/// Используйте `@singleton()` для методов-провайдеров внутри модуля,
-/// чтобы указать, что соответствующий объект должен быть создан
-/// единожды и использоваться во всём приложении (общий синглтон).
-/// Это характерно для систем внедрения зависимостей и сервис-локаторов,
-/// чтобы гарантировать один общий экземпляр.
-///
-/// Пример:
-/// ```dart
-/// @module()
-/// abstract class AppModule extends Module {
-///   @singleton()
-///   Dio dio() => Dio();
-/// }
-/// ```
-///
-/// Будет сгенерирован следующий код:
-/// ```dart
-/// final class $AppModule extends AppModule {
-///   @override
-///   void builder(Scope currentScope) {
-///     bind<Dio>().toProvide(() => dio()).singleton();
-///   }
-/// }
-/// ```
-// ignore: camel_case_types
 final class singleton {
-  /// Creates a [singleton] annotation.
+  /// Creates a [singleton] annotation for DI providers/classes.
   const singleton();
 }

cherrypick_annotations/pubspec.yaml

@@ -1,8 +1,9 @@
 name: cherrypick_annotations
 description: |
   Set of annotations for CherryPick dependency injection library. Enables code generation and declarative DI for Dart & Flutter projects.
-version: 1.1.1
+version: 1.1.2-dev.1
-documentation: https://github.com/pese-git/cherrypick/wiki
+homepage: https://cherrypick-di.dev/
+documentation: https://cherrypick-di.dev/docs/intro
 repository: https://github.com/pese-git/cherrypick/cherrypick_annotations
 issue_tracker: https://github.com/pese-git/cherrypick/issues
 topics:

cherrypick_flutter/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.1.3-dev.10
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+## 1.1.3-dev.9
+
+ - **DOCS**(provider): add detailed English API documentation for CherryPickProvider Flutter integration.
+
+## 1.1.3-dev.8
+
+ - Update a dependency to the latest release.
+
 ## 1.1.3-dev.7
 
  - **FIX**(license): correct urls.

cherrypick_flutter/lib/src/cherrypick_provider.dart

@@ -14,29 +14,87 @@ import 'package:flutter/widgets.dart';
 /// limitations under the License.
 ///
 
+/// {@template cherrypick_flutter_provider}
+/// An [InheritedWidget] that provides convenient integration of CherryPick
+/// dependency injection scopes into the Flutter widget tree.
+///
+/// Place `CherryPickProvider` at the top of your widget subtree to make a
+/// [Scope] (or its descendants) available via `CherryPickProvider.of(context)`.
+///
+/// This is the recommended entry point for connecting CherryPick DI to your
+/// Flutter app or feature area, enabling context-based scope management and
+/// DI resolution in child widgets.
+///
+/// ### Example: Root Integration
+/// ```dart
+/// void main() {
+///   final rootScope = CherryPick.openRootScope()
+///     ..installModules([AppModule()]);
+///   runApp(
+///     CherryPickProvider(
+///       child: MyApp(),
+///     ),
+///   );
+/// }
+///
+/// // In any widget:
+/// final provider = CherryPickProvider.of(context);
+/// final scope = provider.openRootScope();
+/// final myService = scope.resolve<MyService>();
+/// ```
+///
+/// ### Example: Subscope for a Feature/Screen
+/// ```dart
+/// Widget build(BuildContext context) {
+///   final provider = CherryPickProvider.of(context);
+///   final featureScope = provider.openSubScope(scopeName: 'featureA');
+///   return MyFeatureScreen(scope: featureScope);
+/// }
+/// ```
+///
+/// You can use [openRootScope] and [openSubScope] as helpers to get/create scopes.
+/// {@endtemplate}
 final class CherryPickProvider extends InheritedWidget {
+  /// Opens (or returns) the application-wide root [Scope].
+  ///
+  /// Use to make all dependencies available at the top of your widget tree.
   Scope openRootScope() => CherryPick.openRootScope();
 
+  /// Opens a subscope (child [Scope]) with the given [scopeName].
+  ///
+  /// Useful to create isolated feature/module scopes in widget subtrees.
+  /// If [scopeName] is empty, an unnamed scope is created.
   Scope openSubScope({String scopeName = '', String separator = '.'}) =>
       CherryPick.openScope(scopeName: scopeName, separator: separator);
 
-  // Constructor for CherryPickProvider. Initializes with a required rootScope and child widget.
+  /// Creates a [CherryPickProvider] and exposes it to the widget subtree.
+  ///
+  /// Place near the root of your widget tree. Use [child] to provide the subtree.
   const CherryPickProvider({
     super.key,
     required super.child,
   });
 
-  // Method to access the nearest CherryPickProvider instance from the context
+  /// Locates the nearest [CherryPickProvider] up the widget tree from [context].
+  ///
+  /// Throws if not found. Use this to access DI [Scope] controls anywhere below the provider.
+  ///
+  /// Example:
+  /// ```dart
+  /// final provider = CherryPickProvider.of(context);
+  /// final scope = provider.openRootScope();
+  /// ```
   static CherryPickProvider of(BuildContext context) {
-    // Looks up the widget tree for an instance of CherryPickProvider
     final CherryPickProvider? result =
         context.dependOnInheritedWidgetOfExactType<CherryPickProvider>();
-    // Assert to ensure a CherryPickProvider is present in the context
     assert(result != null, 'No CherryPickProvider found in context');
     return result!;
   }
 
-  // Determines whether the widget should notify dependents when it changes
+  /// Controls update notifications for dependent widgets.
+  ///
+  /// Always returns false because the provider itself is stateless:
+  /// changes are to the underlying scopes, not the widget.
   @override
   bool updateShouldNotify(CherryPickProvider oldWidget) {
     return false;

cherrypick_flutter/pubspec.yaml

@@ -1,8 +1,8 @@
 name: cherrypick_flutter
 description: "Flutter library that allows access to the root scope through the context using `CherryPickProvider`."
-version: 1.1.3-dev.7
+version: 1.1.3-dev.10
-homepage: https://pese-git.github.io/cherrypick-site/
+homepage: https://cherrypick-di.dev/
-documentation: https://github.com/pese-git/cherrypick/wiki
+documentation: https://cherrypick-di.dev/docs/intro
 repository: https://github.com/pese-git/cherrypick
 issue_tracker: https://github.com/pese-git/cherrypick/issues
 topics:
@@ -19,7 +19,7 @@ environment:
 dependencies:
   flutter:
     sdk: flutter
-  cherrypick: ^3.0.0-dev.7
+  cherrypick: ^3.0.0-dev.10
 
 dev_dependencies:
   flutter_test:

cherrypick_generator/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 2.0.0-dev.1
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+## 2.0.0-dev.0
+
+> Note: This release has breaking changes.
+
+ - **BREAKING** **DOCS**(generator): improve and unify English documentation and examples for all DI source files.
+
 ## 1.1.1
 
  - **FIX**(license): correct urls.

cherrypick_generator/lib/cherrypick_generator.dart

@@ -1,5 +1,3 @@
-library;
-
 //
 // Copyright 2021 Sergey Penkovsky (sergey.penkovsky@gmail.com)
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,6 +10,28 @@ library;
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
+library;
 
+/// CherryPick code generation library: entry point for build_runner DI codegen.
+///
+/// This library exports generators for CherryPick dependency injection:
+/// - [ModuleGenerator]: Generates DI module classes for all `@module()`-annotated classes.
+/// - [InjectGenerator]: Generates field-injection mixins for classes annotated with `@injectable()`.
+///
+/// These generators are hooked into [build_runner] and cherrypick_generator's builder configuration.
+/// Normally you do not import this directly; instead, add cherrypick_generator
+/// as a dev_dependency and run `dart run build_runner build`.
+///
+/// Example usage in `build.yaml` or your project's workflow:
+/// ```yaml
+/// targets:
+///   $default:
+///     builders:
+///       cherrypick_generator|cherrypick_generator:
+///         generate_for:
+///           - lib/**.dart
+/// ```
+///
+/// For annotation details, see `package:cherrypick_annotations`.
 export 'module_generator.dart';
 export 'inject_generator.dart';

cherrypick_generator/lib/inject_generator.dart

@@ -20,28 +20,85 @@ import 'package:source_gen/source_gen.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:cherrypick_annotations/cherrypick_annotations.dart' as ann;
 
-/// InjectGenerator generates a mixin for a class marked with @injectable()
+/// CherryPick DI field injector generator for codegen.
-/// and injects all fields annotated with @inject(), using CherryPick DI.
 ///
-/// For Future<T> fields it calls .resolveAsync<T>(),
+/// Analyzes all Dart classes marked with `@injectable()` and generates a mixin (for example, `_$ProfileScreen`)
-/// otherwise .resolve<T>() is used. Scope and named qualifiers are supported.
+/// which contains the `_inject` method. This method will assign all fields annotated with `@inject()`
+/// using the CherryPick DI container. Extra annotation qualifiers such as `@named` and `@scope` are respected
+/// for each field. Nullable fields and Future/injectable async dependencies are also supported automatically.
 ///
 /// ---
 ///
-/// InjectGenerator генерирует миксин для класса с аннотацией @injectable()
+/// ### Example usage in a project:
-/// и внедряет все поля, помеченные @inject(), используя DI-фреймворк CherryPick.
 ///
-/// Для Future<T> полей вызывается .resolveAsync<T>(),
+/// ```dart
-/// для остальных — .resolve<T>(). Поддерживаются scope и named qualifier.
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
 ///
+/// @injectable()
+/// class MyScreen with _$MyScreen {
+///   @inject()
+///   late final Logger logger;
+///
+///   @inject()
+///   @named('test')
+///   late final HttpClient client;
+///
+///   @inject()
+///   Future<Analytics>? analytics;
+/// }
+/// ```
+///
+/// After running build_runner, this mixin will be auto-generated:
+///
+/// ```dart
+/// mixin _$MyScreen {
+///   void _inject(MyScreen instance) {
+///     instance.logger = CherryPick.openRootScope().resolve<Logger>();
+///     instance.client = CherryPick.openRootScope().resolve<HttpClient>(named: 'test');
+///     instance.analytics = CherryPick.openRootScope().tryResolveAsync<Analytics>(); // nullable async inject
+///   }
+/// }
+/// ```
+///
+/// You may use the mixin (e.g., `myScreen._inject(myScreen)`) or expose your own public helper for instance field injection.
+///
+/// **Supported scenarios:**
+/// - Ordinary injectable fields: `resolve<T>()`.
+/// - Named qualifiers: `resolve<T>(named: ...)`.
+/// - Scoping: `CherryPick.openScope(scopeName: ...).resolve<T>()`.
+/// - Nullable/incomplete fields: `tryResolve`/`tryResolveAsync`.
+/// - Async dependencies: `Future<T>`/`resolveAsync<T>()`.
+///
+/// See also:
+///   * @inject
+///   * @injectable
 class InjectGenerator extends GeneratorForAnnotation<ann.injectable> {
   const InjectGenerator();
 
-  /// The main entry point for code generation.
+  /// Main entry point for CherryPick field injection code generation.
   ///
-  /// Checks class validity, collects injectable fields, and produces injection code.
+  /// - Only triggers for classes marked with `@injectable()`.
+  /// - Throws an error if used on non-class elements.
+  /// - Scans all fields marked with `@inject()` and gathers qualifiers (if any).
+  /// - Generates Dart code for a mixin that injects all dependencies into the target class instance.
   ///
-  /// Основная точка входа генератора. Проверяет класс, собирает инъектируемые поля и создает код внедрения зависимостей.
+  /// Returns the Dart code as a String defining the new mixin.
+  ///
+  /// Example input (user code):
+  /// ```dart
+  /// @injectable()
+  /// class UserBloc with _$UserBloc {
+  ///   @inject() late final AuthRepository authRepository;
+  /// }
+  /// ```
+  /// Example output (generated):
+  /// ```dart
+  /// mixin _$UserBloc {
+  ///   void _inject(UserBloc instance) {
+  ///     instance.authRepository = CherryPick.openRootScope().resolve<AuthRepository>();
+  ///   }
+  /// }
+  /// ```
   @override
   FutureOr<String> generateForAnnotatedElement(
     Element element,
@@ -63,8 +120,7 @@ class InjectGenerator extends GeneratorForAnnotation<ann.injectable> {
       ..writeln('mixin $mixinName {')
       ..writeln('  void _inject($className instance) {');
 
-    // Collect and process all @inject fields.
+    // Collect and process all @inject fields
-    // Собираем и обрабатываем все поля с @inject.
     final injectFields =
         classElement.fields.where(_isInjectField).map(_parseInjectField);
 
@@ -79,20 +135,20 @@ class InjectGenerator extends GeneratorForAnnotation<ann.injectable> {
     return buffer.toString();
   }
 
-  /// Checks if a field has the @inject annotation.
+  /// Returns true if a field is annotated with `@inject`.
   ///
-  /// Проверяет, отмечено ли поле аннотацией @inject.
+  /// Used to detect which fields should be processed for injection.
   static bool _isInjectField(FieldElement field) {
     return field.metadata.any(
       (m) => m.computeConstantValue()?.type?.getDisplayString() == 'inject',
     );
   }
 
-  /// Parses the field for scope/named qualifiers and determines its type.
+  /// Parses `@inject()` field and extracts all injection metadata
-  /// Returns a [_ParsedInjectField] describing injection information.
+  /// (core type, qualifiers, scope, nullability, etc).
   ///
-  /// Разбирает поле на наличие модификаторов scope/named и выясняет его тип.
+  /// Converts Dart field declaration and all parameterizing injection-related
-  /// Возвращает [_ParsedInjectField] с информацией о внедрении.
+  /// annotations into a [_ParsedInjectField] which is used for codegen.
   static _ParsedInjectField _parseInjectField(FieldElement field) {
     String? scopeName;
     String? namedValue;
@@ -120,8 +176,7 @@ class InjectGenerator extends GeneratorForAnnotation<ann.injectable> {
       isFuture = false;
     }
 
-    // ***
+    // Determine nullability for field types like T? or Future<T?>
-    // Добавим определение nullable для типа (например PostRepository? или Future<PostRepository?>)
     bool isNullable = dartType.nullabilitySuffix ==
             NullabilitySuffix.question ||
         (dartType is ParameterizedType &&
@@ -139,13 +194,17 @@ class InjectGenerator extends GeneratorForAnnotation<ann.injectable> {
     );
   }
 
-  /// Generates a line of code that performs the dependency injection for a field.
+  /// Generates Dart code for a single dependency-injected field based on its metadata.
-  /// Handles resolve/resolveAsync, scoping, and named qualifiers.
   ///
-  /// Генерирует строку кода, которая внедряет зависимость для поля.
+  /// This code will resolve the field from the CherryPick DI container and assign it to the class instance.
-  /// Учитывает resolve/resolveAsync, scoping и named qualifier.
+  /// Correctly dispatches to resolve, tryResolve, resolveAsync, or tryResolveAsync methods,
+  /// and applies container scoping or named resolution where required.
+  ///
+  /// Returns literal Dart code as string (1 line).
+  ///
+  /// Example output:
+  ///   `instance.logger = CherryPick.openRootScope().resolve<Logger>();`
   String _generateInjectionLine(_ParsedInjectField field) {
-    // Используем tryResolve для nullable, иначе resolve
     final resolveMethod = field.isFuture
         ? (field.isNullable
             ? 'tryResolveAsync<${field.coreType}>'
@@ -166,30 +225,29 @@ class InjectGenerator extends GeneratorForAnnotation<ann.injectable> {
   }
 }
 
-/// Data structure representing all information required to generate
+/// Internal structure: describes all required information for generating the injection
-/// injection code for a field.
+/// assignment for a given field.
 ///
-/// Структура данных, содержащая всю информацию,
+/// Not exported. Used as a DTO in the generator for each field.
-/// необходимую для генерации кода внедрения для поля.
 class _ParsedInjectField {
-  /// The name of the field / Имя поля.
+  /// The name of the field to be injected.
   final String fieldName;
 
-  /// The base type name (T or Future<T>) / Базовый тип (T или тип из Future<T>).
+  /// The Dart type to resolve (e.g. `Logger` from `Logger` or `Future<Logger>`).
   final String coreType;
 
-  /// True if the field type is Future<T>; false otherwise
+  /// True if the field is an async dependency (Future<...>), otherwise false.
-  /// Истина, если поле — Future<T>, иначе — ложь.
   final bool isFuture;
 
-  /// Optional scope annotation argument / Опциональное имя scope.
+  /// True if the field accepts null (T?), otherwise false.
+  final bool isNullable;
+
+  /// The scoping for DI resolution, or null to use root scope.
   final String? scopeName;
 
-  /// Optional named annotation argument / Опциональное имя named.
+  /// Name qualifier for named resolution, or null if not set.
   final String? namedValue;
 
-  final bool isNullable;
-
   _ParsedInjectField({
     required this.fieldName,
     required this.coreType,
@@ -200,8 +258,8 @@ class _ParsedInjectField {
   });
 }
 
-/// Builder factory. Used by build_runner.
+/// Factory for creating the build_runner builder for DI field injection.
 ///
-/// Фабрика билдера. Используется build_runner.
+/// Add this builder in your build.yaml if you're invoking CherryPick generators manually.
 Builder injectBuilder(BuilderOptions options) =>
     PartBuilder([InjectGenerator()], '.inject.cherrypick.g.dart');

cherrypick_generator/lib/module_generator.dart

@@ -19,75 +19,89 @@ import 'package:cherrypick_annotations/cherrypick_annotations.dart' as ann;
 import 'src/generated_class.dart';
 
 /// ---------------------------------------------------------------------------
-/// ModuleGenerator for code generation of dependency-injected modules.
+/// CherryPick Module Generator — Codegen for DI modules
 ///
-/// ENGLISH
+/// This generator scans Dart classes annotated with `@module()` and generates
-/// This generator scans for Dart classes annotated with `@module()` and
+/// boilerplate for dependency injection registration automatically. Each public
-/// automatically generates boilerplate code for dependency injection
+/// method in such classes can be annotated to describe how an object should be
-/// (DI) based on the public methods in those classes. Each method can be
+/// bound to the DI container (singleton, factory, named, with parameters, etc).
-/// annotated to describe how an object should be provided to the DI container.
-/// The generated code registers those methods as bindings. This automates the
-/// creation of factories, singletons, and named instances, reducing repetitive
-/// manual code.
 ///
-/// RUSSIAN
+/// The generated code collects all such bind methods and produces a Dart
-/// Генератор зависимостей для DI-контейнера на основе аннотаций.
+/// companion *module registration class* with a `.bindAll()` method, which you
-/// Данный генератор автоматически создаёт код для внедрения зависимостей (DI)
+/// can use from your DI root to automatically register those dependencies.
-/// на основе аннотаций в вашем исходном коде. Когда вы отмечаете класс
+///
-/// аннотацией `@module()`, этот генератор обработает все его публичные методы
+/// ## Example
-/// и автоматически сгенерирует класс с биндингами (регистрациями зависимостей)
+/// ```dart
-/// для DI-контейнера. Это избавляет от написания однообразного шаблонного кода.
+/// import 'package:cherrypick_annotations/cherrypick_annotations.dart';
+///
+/// @module()
+/// abstract class AppModule {
+///   @singleton()
+///   Logger logger() => Logger();
+///
+///   @provide()
+///   ApiService api(Logger logger) => ApiService(logger);
+///
+///   @named('dev')
+///   FakeService fake() => FakeService();
+/// }
+/// ```
+///
+/// After codegen, you will get (simplified):
+/// ```dart
+/// class _\$AppModuleCherrypickModule extend AppModule {
+///   static void bindAll(CherryPickScope scope, AppModule module) {
+///     scope.addSingleton<Logger>(() => module.logger());
+///     scope.addFactory<ApiService>(() => module.api(scope.resolve<Logger>()));
+///     scope.addFactory<FakeService>(() => module.fake(), named: 'dev');
+///   }
+/// }
+/// ```
+///
+/// Use it e.g. in your bootstrap:
+/// ```dart
+/// final scope = CherryPick.openRootScope()..intallModules([_\$AppModuleCherrypickModule()]);
+/// ```
+///
+/// Features supported:
+/// - Singleton, factory, named, parametric, and async providers
+/// - Eliminates all boilerplate for DI registration
+/// - Works with abstract classes and real classes
+/// - Error if @module() is applied to a non-class
+///
+/// See also: [@singleton], [@provide], [@named], [@module]
 /// ---------------------------------------------------------------------------
 
 class ModuleGenerator extends GeneratorForAnnotation<ann.module> {
-  /// -------------------------------------------------------------------------
+  /// Generates Dart source for a class marked with the `@module()` annotation.
-  /// ENGLISH
-  /// Generates the Dart source for a class marked with the `@module()` annotation.
-  /// - [element]: the original Dart class element.
-  /// - [annotation]: the annotation parameters (not usually used here).
-  /// - [buildStep]: the current build step info.
   ///
-  /// RUSSIAN
+  /// Throws [InvalidGenerationSourceError] if used on anything except a class.
-  /// Генерирует исходный код для класса-модуля с аннотацией `@module()`.
+  ///
-  /// [element] — исходный класс, помеченный аннотацией.
+  /// See file-level docs for usage and generated output example.
-  /// [annotation] — значения параметров аннотации.
-  /// [buildStep] — информация о текущем шаге генерации.
-  /// -------------------------------------------------------------------------
   @override
   String generateForAnnotatedElement(
     Element element,
     ConstantReader annotation,
     BuildStep buildStep,
   ) {
-    // Only classes are supported for @module() annotation
-    // Обрабатываются только классы (другие элементы — ошибка)
     if (element is! ClassElement) {
       throw InvalidGenerationSourceError(
-        '@module() can only be applied to classes. / @module() может быть применён только к классам.',
+        '@module() can only be applied to classes.',
         element: element,
       );
     }
 
     final classElement = element;
-
-    // Build a representation of the generated bindings based on class methods /
-    // Создаёт объект, описывающий, какие биндинги нужно сгенерировать на основании методов класса
     final generatedClass = GeneratedClass.fromClassElement(classElement);
-
-    // Generate the resulting Dart code / Генерирует итоговый Dart-код
     return generatedClass.generate();
   }
 }
 
 /// ---------------------------------------------------------------------------
-/// ENGLISH
+/// Codegen builder entry point: register this builder in build.yaml or your package.
-/// Entry point for build_runner. Returns a Builder used to generate code for
-/// every file with a @module() annotation.
 ///
-/// RUSSIAN
+/// Used by build_runner. Generates .module.cherrypick.g.dart files for each
-/// Точка входа для генератора build_runner.
+/// source file with an annotated @module() class.
-/// Возвращает Builder, используемый build_runner для генерации кода для всех
-/// файлов, где встречается @module().
 /// ---------------------------------------------------------------------------
 Builder moduleBuilder(BuilderOptions options) =>
     PartBuilder([ModuleGenerator()], '.module.cherrypick.g.dart');

cherrypick_generator/lib/src/annotation_validator.dart

@@ -15,9 +15,43 @@ import 'package:analyzer/dart/element/element.dart';
 import 'exceptions.dart';
 import 'metadata_utils.dart';
 
-/// Validates annotation combinations and usage patterns
+/// Provides static utility methods for validating annotation usage in CherryPick
+/// dependency injection code generation.
+///
+/// This validator helps ensure that `@provide`, `@instance`, `@singleton`, `@params`,
+/// `@inject`, `@named`, `@module`, and `@injectable` annotations are correctly and safely
+/// combined in your codebase, preventing common configuration and codegen errors before
+/// code is generated.
+///
+/// #### Example Usage
+/// ```dart
+/// void processMethod(MethodElement method) {
+///   AnnotationValidator.validateMethodAnnotations(method);
+/// }
+/// ```
+///
+/// All exceptions are thrown as [AnnotationValidationException] and will include
+/// a helpful message and context.
+///
+/// ---
+/// Typical checks performed by this utility:
+/// - Mutual exclusivity (`@instance` vs `@provide`)
+/// - Required presence for fields and methods
+/// - Proper parameters for `@named` and `@params`
+/// - Correct usage of injectable fields, module class methods, etc.
+///
 class AnnotationValidator {
-  /// Validates annotations on a method element
+  /// Validates annotations for a given [MethodElement].
+  ///
+  /// Checks:
+  ///   - Mutual exclusivity of `@instance` and `@provide`.
+  ///   - That a method is annotated with exactly one DI-producing annotation.
+  ///   - If `@params` is present, that it is used together with `@provide`.
+  ///   - Appropriate usage of `@singleton`.
+  ///   - [@named] syntax and conventions.
+  ///   - Parameter validation for method arguments.
+  ///
+  /// Throws [AnnotationValidationException] on any violation.
   static void validateMethodAnnotations(MethodElement method) {
     final annotations = _getAnnotationNames(method.metadata);
 
@@ -26,14 +60,28 @@ class AnnotationValidator {
     _validateAnnotationParameters(method);
   }
 
-  /// Validates annotations on a field element
+  /// Validates that a [FieldElement] has correct injection annotations.
+  ///
+  /// Specifically, ensures:
+  ///   - Injectable fields are of valid type.
+  ///   - No `void` injection.
+  ///   - Correct scope naming if present.
+  ///
+  /// Throws [AnnotationValidationException] if checks fail.
   static void validateFieldAnnotations(FieldElement field) {
     final annotations = _getAnnotationNames(field.metadata);
 
     _validateInjectFieldAnnotations(field, annotations);
   }
 
-  /// Validates annotations on a class element
+  /// Validates all class-level DI annotations.
+  ///
+  /// Executes checks for:
+  ///   - Module class validity (e.g. must have public DI methods if `@module`).
+  ///   - Injectable class: at least one @inject field, field finalness, etc.
+  ///   - Provides helpful context for error/warning reporting.
+  ///
+  /// Throws [AnnotationValidationException] if checks fail.
   static void validateClassAnnotations(ClassElement classElement) {
     final annotations = _getAnnotationNames(classElement.metadata);
 
@@ -41,6 +89,9 @@ class AnnotationValidator {
     _validateInjectableClassAnnotations(classElement, annotations);
   }
 
+  // --- Internal helpers follow (private) ---
+
+  /// Helper: Returns the names of all annotation types on `metadata`.
   static List<String> _getAnnotationNames(List<ElementAnnotation> metadata) {
     return metadata
         .map((m) => m.computeConstantValue()?.type?.getDisplayString())
@@ -49,6 +100,9 @@ class AnnotationValidator {
         .toList();
   }
 
+  /// Validates that mutually exclusive method annotations are not used together.
+  ///
+  /// For example, `@instance` and `@provide` cannot both be present.
   static void _validateMutuallyExclusiveAnnotations(
     MethodElement method,
     List<String> annotations,
@@ -68,6 +122,10 @@ class AnnotationValidator {
     }
   }
 
+  /// Validates correct annotation combinations, e.g.
+  /// - `@params` must be with `@provide`
+  /// - One of `@instance` or `@provide` must be present for a registration method
+  /// - Validates singleton usage
   static void _validateAnnotationCombinations(
     MethodElement method,
     List<String> annotations,
@@ -105,6 +163,7 @@ class AnnotationValidator {
     }
   }
 
+  /// Singleton-specific method annotation checks.
   static void _validateSingletonUsage(
     MethodElement method,
     List<String> annotations,
@@ -130,6 +189,7 @@ class AnnotationValidator {
     }
   }
 
+  /// Validates extra requirements or syntactic rules for annotation arguments, like @named.
   static void _validateAnnotationParameters(MethodElement method) {
     // Validate @named annotation parameters
     final namedValue = MetadataUtils.getNamedValue(method.metadata);
@@ -170,11 +230,11 @@ class AnnotationValidator {
     }
   }
 
+  /// Checks that @params is used with compatible parameter type.
   static void _validateParamsParameter(
       ParameterElement param, MethodElement method) {
     // @params parameter should typically be dynamic or Map<String, dynamic>
     final paramType = param.type.getDisplayString();
-
     if (paramType != 'dynamic' &&
         paramType != 'Map<String, dynamic>' &&
         paramType != 'Map<String, dynamic>?') {
@@ -194,6 +254,7 @@ class AnnotationValidator {
     }
   }
 
+  /// Checks field-level annotation for valid injectable fields.
   static void _validateInjectFieldAnnotations(
     FieldElement field,
     List<String> annotations,
@@ -227,6 +288,7 @@ class AnnotationValidator {
     }
   }
 
+  /// Checks @module usage: must have at least one DI method, each with DI-annotation.
   static void _validateModuleClassAnnotations(
     ClassElement classElement,
     List<String> annotations,
@@ -268,6 +330,7 @@ class AnnotationValidator {
     }
   }
 
+  /// Checks @injectable usage on classes and their fields.
   static void _validateInjectableClassAnnotations(
     ClassElement classElement,
     List<String> annotations,

cherrypick_generator/lib/src/bind_parameters_spec.dart

@@ -12,57 +12,59 @@
 //
 
 /// ----------------------------------------------------------------------------
-/// BindParameterSpec - describes a single method parameter and how to resolve it.
+/// BindParameterSpec
 ///
-/// ENGLISH
+/// Describes a single parameter for a DI provider/factory/binding method,
-/// Describes a single parameter for a provider/binding method in the DI system.
+/// specifying how that parameter is to be resolved in generated code.
-/// Stores the parameter type, its optional `@named` key for named resolution,
-/// and whether it is a runtime "params" argument. Used to generate code that
-/// resolves dependencies from the DI scope:
-///   - If the parameter is a dependency type (e.g. SomeDep), emits:
-///         currentScope.resolve<SomeDep>()
-///   - If the parameter is named, emits:
-///         currentScope.resolve<SomeDep>(named: 'yourName')
-///   - If it's a runtime parameter (e.g. via @params()), emits:
-///         args
 ///
-/// RUSSIAN
+/// Stores the parameter's type name, optional `@named` identifier (for named DI resolution),
-/// Описывает один параметр метода в DI, и его способ разрешения из контейнера.
+/// and a flag for runtime (@params) arguments. Used in CherryPick generator
-/// Сохраняет имя типа, дополнительное имя (если параметр аннотирован через @named),
+/// for creating argument lists when invoking factories or provider methods.
-/// и признак runtime-параметра (@params).
+///
-/// Для обычной зависимости типа (например, SomeDep) генерирует строку вида:
+/// ## Example usage
-///   currentScope.resolve<SomeDep>()
+/// ```dart
-/// Для зависимости с именем:
+/// // Binding method: @provide() Logger provideLogger(@named('debug') Config config, @params Map<String, dynamic> args)
-///   currentScope.resolve<SomeDep>(named: 'имя')
+/// final namedParam = BindParameterSpec('Config', 'debug');
-/// Для runtime-параметра:
+/// final runtimeParam = BindParameterSpec('Map<String, dynamic>', null, isParams: true);
-///   args
+/// print(namedParam.generateArg()); // prints: currentScope.resolve<Config>(named: 'debug')
+/// print(runtimeParam.generateArg()); // prints: args
+/// ```
+///
+/// ## Code generation logic
+/// - Injected:  currentScope.resolve<Service>()
+/// - Named:     currentScope.resolve<Service>(named: 'name')
+/// - @params:   args
 /// ----------------------------------------------------------------------------
 class BindParameterSpec {
-  /// Type name of the parameter (e.g. SomeService)
+  /// The type name of the parameter (e.g., 'UserRepository')
-  /// Имя типа параметра (например, SomeService)
   final String typeName;
 
-  /// Optional name for named resolution (from @named)
+  /// If non-null, this is the named-key for DI resolution (from @named).
-  /// Необязательное имя для разрешения по имени (если аннотировано через @named)
   final String? named;
 
-  /// True if this parameter uses @params and should be provided from runtime args
+  /// True if this parameter is a runtime param (annotated with @params and
-  /// Признак, что параметр — runtime (через @params)
+  /// filled by a runtime argument map).
   final bool isParams;
 
   BindParameterSpec(this.typeName, this.named, {this.isParams = false});
 
-  /// --------------------------------------------------------------------------
+  /// Generates Dart code to resolve this parameter in the DI container.
-  /// generateArg
   ///
-  /// ENGLISH
+  /// - For normal dependencies: resolves by type
-  /// Generates Dart code for resolving the dependency from the DI scope,
+  /// - For named dependencies: resolves by type and name
-  /// considering type, named, and param-argument.
+  /// - For @params: uses the supplied params variable (default 'args')
   ///
-  /// RUSSIAN
+  /// ## Example
-  /// Генерирует строку для получения зависимости из DI scope (с учётом имени
+  /// ```dart
-  /// и типа параметра или runtime-режима @params).
+  /// final a = BindParameterSpec('Api', null); // normal
-  /// --------------------------------------------------------------------------
+  /// print(a.generateArg()); // currentScope.resolve<Api>()
+  ///
+  /// final b = BindParameterSpec('Api', 'prod'); // named
+  /// print(b.generateArg()); // currentScope.resolve<Api>(named: 'prod')
+  ///
+  /// final c = BindParameterSpec('Map<String,dynamic>', null, isParams: true); // params
+  /// print(c.generateArg()); // args
+  /// ```
   String generateArg([String paramsVar = 'args']) {
     if (isParams) {
       return paramsVar;

cherrypick_generator/lib/src/bind_spec.dart

@@ -19,62 +19,64 @@ import 'exceptions.dart';
 import 'type_parser.dart';
 import 'annotation_validator.dart';
 
+/// Enum representing the binding annotation applied to a module method.
 enum BindingType {
+  /// Direct instance returned from the method (@instance).
   instance,
+
+  /// Provider/factory function (@provide).
   provide;
 }
 
 /// ---------------------------------------------------------------------------
-/// BindSpec -- describes a binding specification generated for a dependency.
+/// BindSpec
 ///
-/// ENGLISH
+/// Describes a DI container binding as generated from a single public factory,
-/// Represents all the data necessary to generate a DI binding for a single
+/// instance, or provider method of a module (annotated with @instance or @provide).
-/// method in a module class. Each BindSpec corresponds to one public method
-/// and contains information about its type, provider method, lifecycle (singleton),
-/// parameters (with their annotations), binding strategy (instance/provide),
-/// asynchronous mode, and named keys. It is responsible for generating the
-/// correct Dart code to register this binding with the DI container, in both
-/// sync and async cases, with and without named or runtime arguments.
 ///
-/// RUSSIAN
+/// Includes all annotation-driven parameters required to generate valid DI
-/// Описывает параметры для создания одного биндинга зависимости (binding spec).
+/// registration Dart code in CherryPick:
-/// Каждый биндинг соответствует одному публичному методу класса-модуля и
+/// - Return type
-/// содержит всю информацию для генерации кода регистрации этого биндинга в
+/// - Provider method name
-/// DI-контейнере: тип возвращаемой зависимости, имя метода, параметры, аннотации
+/// - Singleton flag
-/// (@singleton, @named, @instance, @provide), асинхронность, признак runtime
+/// - Named identifier (from @named)
-/// аргументов и др. Генерирует правильный Dart-код для регистрации биндера.
+/// - List of resolved or runtime (@params) parameters
+/// - Binding mode (instance/provide)
+/// - Async and parametric variants
+///
+/// ## Example usage
+/// ```dart
+/// // Suppose @provide() Api api(@named('test') Client client)
+/// final bindSpec = BindSpec.fromMethod(methodElement);
+/// print(bindSpec.generateBind(2)); //   bind<Api>().toProvide(() => api(currentScope.resolve<Client>(named: 'test')));
+/// ```
 /// ---------------------------------------------------------------------------
 class BindSpec {
   /// The type this binding provides (e.g. SomeService)
-  /// Тип, который предоставляет биндинг (например, SomeService)
   final String returnType;
 
-  /// Method name that implements the binding
+  /// Binding provider/factory method name
-  /// Имя метода, который реализует биндинг
   final String methodName;
 
-  /// Optional name for named dependency (from @named)
+  /// Named identifier for DI resolution (null if unnamed)
-  /// Необязательное имя, для именованной зависимости (используется с @named)
   final String? named;
 
-  /// Whether the dependency is a singleton (@singleton annotation)
+  /// If true, binding is registered as singleton in DI
-  /// Является ли зависимость синглтоном (имеется ли аннотация @singleton)
   final bool isSingleton;
 
-  /// List of method parameters to inject dependencies with
+  /// Provider/factory method parameters (in order)
-  /// Список параметров, которые требуются методу для внедрения зависимостей
   final List<BindParameterSpec> parameters;
 
-  /// Binding type: 'instance' or 'provide' (@instance or @provide)
+  /// Instance vs provider mode, from annotation choice
-  final BindingType bindingType; // 'instance' | 'provide'
+  final BindingType bindingType;
 
-  /// True if the method is asynchronous and uses instance binding (Future)
+  /// Async flag for .toInstanceAsync()
   final bool isAsyncInstance;
 
-  /// True if the method is asynchronous and uses provide binding (Future)
+  /// Async flag for .toProvideAsync()
   final bool isAsyncProvide;
 
-  /// True if the binding method accepts runtime "params" argument (@params)
+  /// True if a @params runtime parameter is present
   final bool hasParams;
 
   BindSpec({
@@ -89,20 +91,12 @@ class BindSpec {
     required this.hasParams,
   });
 
-  /// -------------------------------------------------------------------------
+  /// Generates a Dart code line for binding registration.
-  /// generateBind
   ///
-  /// ENGLISH
+  /// Example (single-line):
-  /// Generates a line of Dart code registering the binding with the DI framework.
+  ///   bind<Api>().toProvide(() => provideApi(currentScope.resolve<Client>(named: 'test'))).withName('prod').singleton();
-  /// Produces something like:
-  ///   bind<Type>().toProvide(() => method(args)).withName('name').singleton();
-  /// Indent parameter allows formatted multiline output.
   ///
-  /// RUSSIAN
+  /// The [indent] argument sets the space indentation for pretty-printing.
-  /// Формирует dart-код для биндинга, например:
-  ///   bind<Type>().toProvide(() => method(args)).withName('name').singleton();
-  /// Параметр [indent] задаёт отступ для красивого форматирования кода.
-  /// -------------------------------------------------------------------------
   String generateBind(int indent) {
     final indentStr = ' ' * indent;
     final provide = _generateProvideClause(indent);
@@ -151,7 +145,7 @@ class BindSpec {
     return _generatePlainProvideClause(indent);
   }
 
-  /// EN / RU: Supports runtime parameters (@params).
+  /// Generates code when using runtime parameters (@params).
   String _generateWithParamsProvideClause(int indent) {
     // Safe variable name for parameters.
     const paramVar = 'args';
@@ -178,7 +172,7 @@ class BindSpec {
     }
   }
 
-  /// EN / RU: Supports only injected dependencies, not runtime (@params).
+  /// Generates code when only resolved (not runtime) arguments used.
   String _generatePlainProvideClause(int indent) {
     final argsStr = parameters.map((p) => p.generateArg()).join(', ');
 
@@ -241,16 +235,17 @@ class BindSpec {
   /// -------------------------------------------------------------------------
   /// fromMethod
   ///
-  /// ENGLISH
+  /// Constructs a [BindSpec] from an analyzer [MethodElement].
-  /// Creates a BindSpec from a module class method by analyzing its return type,
-  /// annotations, list of parameters (with their own annotations), and async-ness.
-  /// Throws if a method does not have the required @instance() or @provide().
   ///
-  /// RUSSIAN
+  /// Validates and parses all type annotations, method/parameter DI hints,
-  /// Создаёт спецификацию биндинга (BindSpec) из метода класса-модуля, анализируя
+  /// and derives async and parametric flags as needed.
-  /// возвращаемый тип, аннотации, параметры (и их аннотации), а также факт
+  ///
-  /// асинхронности. Если нет @instance или @provide — кидает ошибку.
+  /// ## Example
-  /// -------------------------------------------------------------------------
+  /// ```dart
+  /// final bindSpec = BindSpec.fromMethod(methodElement);
+  /// print(bindSpec.returnType); // e.g., 'Logger'
+  /// ```
+  /// Throws [AnnotationValidationException] or [CodeGenerationException] if invalid.
   static BindSpec fromMethod(MethodElement method) {
     try {
       // Validate method annotations

cherrypick_generator/lib/src/exceptions.dart

@@ -14,10 +14,36 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:source_gen/source_gen.dart';
 
-/// Enhanced exception class for CherryPick generator with detailed context information
+/// ---------------------------------------------------------------------------
+/// CherryPickGeneratorException
+///
+/// The base exception for all CherryPick code generation and annotation
+/// validation errors. This exception provides enhanced diagnostics including
+/// the error category, helpful suggestions, and additional debugging context.
+///
+/// All errors are structured to be as helpful as possible for users
+/// running build_runner and for CherryPick contributors debugging generators.
+///
+/// ## Example usage:
+/// ```dart
+/// if (someErrorCondition) {
+///   throw AnnotationValidationException(
+///     'Custom message about what went wrong',
+///     element: methodElement,
+///     suggestion: 'Add @provide() or @instance() annotation',
+///     context: {'found_annotations': annotations},
+///   );
+/// }
+/// ```
+/// ---------------------------------------------------------------------------
 class CherryPickGeneratorException extends InvalidGenerationSourceError {
+  /// A string describing the error category (for grouping).
   final String category;
+
+  /// An optional suggestion string for resolving the error.
   final String? suggestion;
+
+  /// Arbitrary key-value map for additional debugging information.
   final Map<String, dynamic>? context;
 
   CherryPickGeneratorException(
@@ -50,7 +76,7 @@ class CherryPickGeneratorException extends InvalidGenerationSourceError {
     buffer.writeln('  Type: ${element.runtimeType}');
     buffer.writeln('  Location: ${element.source?.fullName ?? 'unknown'}');
 
-    // Note: enclosingElement may not be available in all analyzer versions
+    // Try to show enclosing element info for extra context
     try {
       final enclosing = (element as dynamic).enclosingElement;
       if (enclosing != null) {
@@ -60,7 +86,7 @@ class CherryPickGeneratorException extends InvalidGenerationSourceError {
       // Ignore if enclosingElement is not available
     }
 
-    // Additional context
+    // Arbitrary user context
     if (context != null && context.isNotEmpty) {
       buffer.writeln('');
       buffer.writeln('Additional Context:');
@@ -69,7 +95,7 @@ class CherryPickGeneratorException extends InvalidGenerationSourceError {
       });
     }
 
-    // Suggestion
+    // Hint/suggestion if present
     if (suggestion != null) {
       buffer.writeln('');
       buffer.writeln('💡 Suggestion: $suggestion');
@@ -79,7 +105,24 @@ class CherryPickGeneratorException extends InvalidGenerationSourceError {
   }
 }
 
-/// Specific exception types for different error categories
+/// ---------------------------------------------------------------------------
+/// AnnotationValidationException
+///
+/// Thrown when annotation usage is invalid (e.g., missing required annotation,
+/// mutually exclusive annotations, or incorrect @named format).
+///
+/// Grouped as category "ANNOTATION_VALIDATION".
+///
+/// ## Example:
+/// ```dart
+/// throw AnnotationValidationException(
+///   '@instance and @provide cannot be used together',
+///   element: method,
+///   suggestion: 'Use only one of @instance or @provide.',
+///   context: {'method_name': method.displayName},
+/// );
+/// ```
+/// ---------------------------------------------------------------------------
 class AnnotationValidationException extends CherryPickGeneratorException {
   AnnotationValidationException(
     super.message, {
@@ -89,6 +132,24 @@ class AnnotationValidationException extends CherryPickGeneratorException {
   }) : super(category: 'ANNOTATION_VALIDATION');
 }
 
+/// ---------------------------------------------------------------------------
+/// TypeParsingException
+///
+/// Thrown when a Dart type cannot be interpreted/parsed for DI,
+/// or if it's not compatible (void, raw Future, etc).
+///
+/// Grouped as category "TYPE_PARSING".
+///
+/// ## Example:
+/// ```dart
+/// throw TypeParsingException(
+///   'Cannot parse injected type',
+///   element: field,
+///   suggestion: 'Specify a concrete type. Avoid dynamic and raw Future.',
+///   context: {'type': field.type.getDisplayString()},
+/// );
+/// ```
+/// ---------------------------------------------------------------------------
 class TypeParsingException extends CherryPickGeneratorException {
   TypeParsingException(
     super.message, {
@@ -98,6 +159,23 @@ class TypeParsingException extends CherryPickGeneratorException {
   }) : super(category: 'TYPE_PARSING');
 }
 
+/// ---------------------------------------------------------------------------
+/// CodeGenerationException
+///
+/// Thrown on unexpected code generation or formatting failures
+/// during generator execution.
+///
+/// Grouped as category "CODE_GENERATION".
+///
+/// ## Example:
+/// ```dart
+/// throw CodeGenerationException(
+///   'Could not generate module binding',
+///   element: classElement,
+///   suggestion: 'Check module class methods and signatures.',
+/// );
+/// ```
+/// ---------------------------------------------------------------------------
 class CodeGenerationException extends CherryPickGeneratorException {
   CodeGenerationException(
     super.message, {
@@ -107,6 +185,23 @@ class CodeGenerationException extends CherryPickGeneratorException {
   }) : super(category: 'CODE_GENERATION');
 }
 
+/// ---------------------------------------------------------------------------
+/// DependencyResolutionException
+///
+/// Thrown if dependency information (for example, types or names)
+/// cannot be resolved during code generation analysis.
+///
+/// Grouped as category "DEPENDENCY_RESOLUTION".
+///
+/// ## Example:
+/// ```dart
+/// throw DependencyResolutionException(
+///   'Dependency type not found in scope',
+///   element: someElement,
+///   suggestion: 'Check CherryPick registration for this type.',
+/// );
+/// ```
+/// ---------------------------------------------------------------------------
 class DependencyResolutionException extends CherryPickGeneratorException {
   DependencyResolutionException(
     super.message, {

cherrypick_generator/lib/src/generated_class.dart

@@ -12,45 +12,48 @@
 //
 
 import 'package:analyzer/dart/element/element.dart';
-
 import 'bind_spec.dart';
 
 /// ---------------------------------------------------------------------------
-/// GeneratedClass -- represents the result of processing a single module class.
+/// GeneratedClass
 ///
-/// ENGLISH
+/// Represents a processed DI module class with all its binding methods analyzed.
-/// Encapsulates all the information produced from analyzing a DI module class:
+/// Stores:
-/// - The original class name,
+///   - The original class name,
-/// - Its generated class name (e.g., `$SomeModule`),
+///   - The generated implementation class name (with $ prefix),
-/// - The collection of bindings (BindSpec) for all implemented provider methods.
+///   - The list of all BindSpec for the module methods,
+///   - The source file name for reference or directive generation.
 ///
-/// Also provides code generation functionality, allowing to generate the source
+/// Provides static and instance methods to construct from a ClassElement
-/// code for the derived DI module class, including all binding registrations.
+/// and generate Dart source code for the resulting DI registration class.
 ///
-/// RUSSIAN
+/// ## Example usage
-/// Описывает результат обработки одного класса-модуля DI:
+/// ```dart
-/// - Имя оригинального класса,
+/// final gen = GeneratedClass.fromClassElement(myModuleClassElement);
-/// - Имя генерируемого класса (например, `$SomeModule`),
+/// print(gen.generate());
-/// - Список всех бидингов (BindSpec) — по публичным методам модуля.
+/// /*
-///
+/// Produces:
-/// Также содержит функцию генерации исходного кода для этого класса и
+/// final class $MyModule extends MyModule {
-/// регистрации всех зависимостей через bind(...).
+///   @override
+///   void builder(Scope currentScope) {
+///     bind<Service>().toProvide(() => provideService(currentScope.resolve<Dep>()));
+///     ...
+///   }
+/// }
+/// */
+/// ```
 /// ---------------------------------------------------------------------------
 class GeneratedClass {
-  /// The name of the original module class.
+  /// Name of the original Dart module class.
-  /// Имя исходного класса-модуля
   final String className;
 
-  /// The name of the generated class (e.g., $SomeModule).
+  /// Name of the generated class, e.g. `$MyModule`
-  /// Имя генерируемого класса (например, $SomeModule)
   final String generatedClassName;
 
-  /// List of all discovered bindings for the class.
+  /// Binding specs for all provider/factory methods in the class.
-  /// Список всех обнаруженных биндингов
   final List<BindSpec> binds;
 
-  /// Source file name for the part directive
+  /// Source filename of the module class (for code references).
-  /// Имя исходного файла для part директивы
   final String sourceFile;
 
   GeneratedClass(
@@ -63,16 +66,15 @@ class GeneratedClass {
   /// -------------------------------------------------------------------------
   /// fromClassElement
   ///
-  /// ENGLISH
+  /// Creates a [GeneratedClass] by analyzing a Dart [ClassElement].
-  /// Static factory: creates a GeneratedClass from a Dart ClassElement (AST representation).
+  /// Collects all public non-abstract methods, creates a [BindSpec] for each,
-  /// Discovers all non-abstract methods, builds BindSpec for each, and computes the
+  /// and infers the generated class name using a `$` prefix.
-  /// generated class name by prefixing `$`.
   ///
-  /// RUSSIAN
+  /// ## Example usage
-  /// Строит объект класса по элементу AST (ClassElement): имя класса,
+  /// ```dart
-  /// сгенерированное имя, список BindSpec по всем не абстрактным методам.
+  /// final gen = GeneratedClass.fromClassElement(classElement);
-  /// Имя ген-класса строится с префиксом `$`.
+  /// print(gen.generatedClassName); // e.g. $AppModule
-  /// -------------------------------------------------------------------------
+  /// ```
   static GeneratedClass fromClassElement(ClassElement element) {
     final className = element.displayName;
     // Generated class name with '$' prefix (standard for generated Dart code).
@@ -91,16 +93,19 @@ class GeneratedClass {
   /// -------------------------------------------------------------------------
   /// generate
   ///
-  /// ENGLISH
+  /// Generates the Dart source code for the DI registration class.
-  /// Generates Dart source code for the DI module class. The generated class
+  /// The generated class extends the original module, and the `builder` method
-  /// inherits from the original, overrides the 'builder' method, and registers
+  /// registers all bindings (dependencies) into the DI scope.
-  /// all bindings in the DI scope.
   ///
-  /// RUSSIAN
+  /// ## Example output
-  /// Генерирует исходный Dart-код для класса-модуля DI.
+  /// ```dart
-  /// Новая версия класса наследует оригинальный, переопределяет builder(Scope),
+  /// final class $UserModule extends UserModule {
-  /// и регистрирует все зависимости через методы bind<Type>()...
+  ///   @override
-  /// -------------------------------------------------------------------------
+  ///   void builder(Scope currentScope) {
+  ///     bind<Service>().toProvide(() => provideService(currentScope.resolve<Dep>()));
+  ///   }
+  /// }
+  /// ```
   String generate() {
     final buffer = StringBuffer()
       ..writeln('final class $generatedClassName extends $className {')
@@ -108,7 +113,6 @@ class GeneratedClass {
       ..writeln('  void builder(Scope currentScope) {');
 
     // For each binding, generate bind<Type>() code string.
-    // Для каждого биндинга — генерируем строку bind<Type>()...
     for (final bind in binds) {
       buffer.writeln(bind.generateBind(4));
     }

cherrypick_generator/lib/src/metadata_utils.dart

@@ -14,30 +14,32 @@
 import 'package:analyzer/dart/element/element.dart';
 
 /// ---------------------------------------------------------------------------
-/// MetadataUtils -- utilities for analyzing method and parameter annotations.
+/// MetadataUtils
 ///
-/// ENGLISH
+/// Static utilities for querying and extracting information from
-/// Provides static utility methods to analyze Dart annotations on methods or
+/// Dart annotations ([ElementAnnotation]) in the context of code generation,
-/// parameters. For instance, helps to find if an element is annotated with
+/// such as checking for the presence of specific DI-related annotations.
-/// `@named()`, `@singleton()`, or other meta-annotations used in this DI framework.
+/// Designed to be used internally by code generation and validation routines.
 ///
-/// RUSSIAN
+/// # Example usage
-/// Утилиты для разбора аннотаций методов и параметров.
+/// ```dart
-/// Позволяют находить наличие аннотаций, например, @named() и @singleton(),
+/// if (MetadataUtils.anyMeta(method.metadata, 'singleton')) {
-/// у методов и параметров. Используется для анализа исходного кода при генерации.
+///   // The method is annotated with @singleton
+/// }
+/// final name = MetadataUtils.getNamedValue(field.metadata);
+/// if (name != null) print('@named value: $name');
+/// ```
 /// ---------------------------------------------------------------------------
 class MetadataUtils {
-  /// -------------------------------------------------------------------------
+  /// Checks whether any annotation in [meta] matches the [typeName]
-  /// anyMeta
+  /// (type name is compared in a case-insensitive manner and can be partial).
   ///
-  /// ENGLISH
+  /// Returns true if an annotation (such as @singleton, @provide, @named) is found.
-  /// Checks if any annotation in the list has a type name that contains
-  /// [typeName] (case insensitive).
   ///
-  /// RUSSIAN
+  /// Example:
-  /// Проверяет: есть ли среди аннотаций метка, имя которой содержит [typeName]
+  /// ```dart
-  /// (регистр не учитывается).
+  /// bool isSingleton = MetadataUtils.anyMeta(myMethod.metadata, 'singleton');
-  /// -------------------------------------------------------------------------
+  /// ```
   static bool anyMeta(List<ElementAnnotation> meta, String typeName) {
     return meta.any((m) =>
         m
@@ -49,17 +51,15 @@ class MetadataUtils {
         false);
   }
 
-  /// -------------------------------------------------------------------------
+  /// Extracts the string value from a `@named('value')` annotation if present in [meta].
-  /// getNamedValue
   ///
-  /// ENGLISH
+  /// Returns the named value or `null` if not annotated.
-  /// Retrieves the value from a `@named('value')` annotation if present.
-  /// Returns the string value or null if not found.
   ///
-  /// RUSSIAN
+  /// Example:
-  /// Находит значение из аннотации @named('значение').
+  /// ```dart
-  /// Возвращает строку значения, если аннотация присутствует; иначе null.
+  /// // For: @named('dev') ApiClient provideApi() ...
-  /// -------------------------------------------------------------------------
+  /// final named = MetadataUtils.getNamedValue(method.metadata); // 'dev'
+  /// ```
   static String? getNamedValue(List<ElementAnnotation> meta) {
     for (final m in meta) {
       final cv = m.computeConstantValue();

cherrypick_generator/lib/src/type_parser.dart

@@ -16,9 +16,35 @@ import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'exceptions.dart';
 
-/// Enhanced type parser that uses AST analysis instead of regular expressions
+/// Utility for analyzing and parsing Dart types for CherryPick DI code generation.
+///
+/// This type parser leverages the Dart analyzer AST to extract nuanced information
+/// from Dart types encountered in the source code, in particular for dependency
+/// injection purposes. It is capable of extracting nullability, generics,
+/// and Future-related metadata with strong guarantees and handles even nested generics.
+///
+/// # Example usage for parsing types:
+/// ```dart
+/// final parsed = TypeParser.parseType(method.returnType, method);
+/// print(parsed);
+/// print(parsed.resolveMethodName); // e.g. "resolveAsync" or "tryResolve"
+/// ```
+///
+/// # Supported scenarios:
+/// - Nullable types (e.g., `List<String>?`)
+/// - Generic types (e.g., `Map<String, User>`)
+/// - Async types (`Future<T>`, including nested generics)
+/// - Validation for DI compatibility (throws for `void`, warns on `dynamic`)
 class TypeParser {
-  /// Parses a DartType and extracts detailed type information
+  /// Parses a [DartType] and extracts detailed type information for use in code generation.
+  ///
+  /// If a type is not suitable or cannot be parsed, a [TypeParsingException] is thrown.
+  ///
+  /// Example:
+  /// ```dart
+  /// final parsed = TypeParser.parseType(field.type, field);
+  /// if (parsed.isNullable) print('Field is nullable');
+  /// ```
   static ParsedType parseType(DartType dartType, Element context) {
     try {
       return _parseTypeInternal(dartType, context);
@@ -49,7 +75,7 @@ class TypeParser {
       return _parseGenericType(dartType, context, isNullable);
     }
 
-    // Simple type
+    // Simple type (non-generic, non-Future)
     return ParsedType(
       displayString: displayString,
       coreType: displayString.replaceAll('?', ''),
@@ -103,7 +129,15 @@ class TypeParser {
     );
   }
 
-  /// Validates that a type is suitable for dependency injection
+  /// Validates that a parsed type is suitable for dependency injection.
+  ///
+  /// Throws [TypeParsingException] for void and may warn for dynamic.
+  ///
+  /// Example:
+  /// ```dart
+  /// final parsed = TypeParser.parseType(field.type, field);
+  /// TypeParser.validateInjectableType(parsed, field);
+  /// ```
   static void validateInjectableType(ParsedType parsedType, Element context) {
     // Check for void type
     if (parsedType.coreType == 'void') {
@@ -131,7 +165,7 @@ class TypeParser {
   }
 }
 
-/// Represents a parsed type with detailed information
+/// Represents a parsed type with full metadata for code generation.
 class ParsedType {
   /// The full display string of the type (e.g., "Future<List<String>?>")
   final String displayString;
@@ -139,19 +173,19 @@ class ParsedType {
   /// The core type name without nullability and Future wrapper (e.g., "List<String>")
   final String coreType;
 
-  /// Whether the type is nullable
+  /// True if nullable (has `?`)
   final bool isNullable;
 
-  /// Whether the type is wrapped in Future
+  /// True if this type is a `Future<T>`
   final bool isFuture;
 
-  /// Whether the type has generic parameters
+  /// True if the type is a generic type (`List<T>`)
   final bool isGeneric;
 
-  /// Parsed type arguments for generic types
+  /// List of parsed type arguments in generics, if any.
   final List<ParsedType> typeArguments;
 
-  /// For Future types, the inner type
+  /// For `Future<T>`, this is the type inside the `Future`.
   final ParsedType? innerType;
 
   const ParsedType({
@@ -164,7 +198,11 @@ class ParsedType {
     this.innerType,
   });
 
-  /// Returns the type string suitable for code generation
+  /// Generates the type string suitable for code generation.
+  ///
+  /// - For futures, the codegen type of the inner type is returned
+  /// - For generics, returns e.g. `List<User>`
+  /// - For plain types, just the name
   String get codeGenType {
     if (isFuture && innerType != null) {
       return innerType!.codeGenType;
@@ -179,10 +217,10 @@ class ParsedType {
     return coreType;
   }
 
-  /// Returns whether this type should use tryResolve instead of resolve
+  /// True if this type should use `tryResolve` instead of `resolve` for DI.
   bool get shouldUseTryResolve => isNullable;
 
-  /// Returns the appropriate resolve method name
+  /// Returns the method name for DI, e.g. "resolve", "tryResolveAsync", etc.
   String get resolveMethodName {
     if (isFuture) {
       return shouldUseTryResolve ? 'tryResolveAsync' : 'resolveAsync';

cherrypick_generator/pubspec.yaml

@@ -2,8 +2,9 @@ name: cherrypick_generator
 description: |
   Source code generator for the cherrypick dependency injection system. Processes annotations to generate binding and module code for Dart & Flutter projects.
 
-version: 1.1.1
+version: 2.0.0-dev.1
-documentation: https://github.com/pese-git/cherrypick/wiki
+homepage: https://cherrypick-di.dev/
+documentation: https://cherrypick-di.dev/docs/intro
 repository: https://github.com/pese-git/cherrypick/cherrypick_generator
 issue_tracker: https://github.com/pese-git/cherrypick/issues
 topics:
@@ -18,7 +19,7 @@ environment:
 
 # Add regular dependencies here.
 dependencies:
-  cherrypick_annotations: ^1.1.1
+  cherrypick_annotations: ^1.1.2-dev.1
   analyzer: ^7.0.0
   dart_style: ^3.0.0
   build: ^2.4.1

cherrypick_generator/test/bind_spec_test.dart

@@ -244,8 +244,7 @@ void main() {
         final result = bindSpec.generateBind(4);
         expect(
             result,
-            equals(
+            equals("    bind<ApiClient>()\n"
-                "    bind<ApiClient>()\n"
                 "        .toProvideAsync(() => createApiClient())\n"
                 "        .withName('mainApi')\n"
                 "        .singleton();"));

examples/client_app/pubspec.lock

@@ -127,28 +127,28 @@ packages:
       path: "../../cherrypick"
       relative: true
     source: path
-    version: "3.0.0-dev.5"
+    version: "3.0.0-dev.9"
   cherrypick_annotations:
     dependency: "direct main"
     description:
       path: "../../cherrypick_annotations"
       relative: true
     source: path
-    version: "1.1.0"
+    version: "1.1.2-dev.0"
   cherrypick_flutter:
     dependency: "direct main"
     description:
       path: "../../cherrypick_flutter"
       relative: true
     source: path
-    version: "1.1.3-dev.5"
+    version: "1.1.3-dev.9"
   cherrypick_generator:
     dependency: "direct dev"
     description:
       path: "../../cherrypick_generator"
       relative: true
     source: path
-    version: "1.1.0"
+    version: "2.0.0-dev.0"
   clock:
     dependency: transitive
     description:

examples/postly/lib/app.dart

@@ -2,6 +2,7 @@ import 'package:cherrypick/cherrypick.dart';
 import 'package:cherrypick_annotations/cherrypick_annotations.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:talker_flutter/talker_flutter.dart';
 
 import 'domain/repository/post_repository.dart';
 import 'presentation/bloc/post_bloc.dart';
@@ -9,26 +10,40 @@ import 'router/app_router.dart';
 
 part 'app.inject.cherrypick.g.dart';
 
+class TalkerProvider extends InheritedWidget {
+  final Talker talker;
+  const TalkerProvider({required this.talker, required super.child, super.key});
+  static Talker of(BuildContext context) =>
+      context.dependOnInheritedWidgetOfExactType<TalkerProvider>()!.talker;
+  @override
+  bool updateShouldNotify(TalkerProvider oldWidget) =>
+      oldWidget.talker != talker;
+}
+
 @injectable()
 class MyApp extends StatelessWidget with _$MyApp {
   final _appRouter = AppRouter();
+  final Talker talker;
 
   @named('repo')
   @inject()
   late final PostRepository repository;
 
-  MyApp({super.key}) {
+  MyApp({super.key, required this.talker}) {
     _inject(this);
   }
 
   @override
   Widget build(BuildContext context) {
-    return BlocProvider(
+    return TalkerProvider(
-      create: (_) => PostBloc(repository),
+      talker: talker,
-      child: MaterialApp.router(
+      child: BlocProvider(
-        routeInformationParser: _appRouter.defaultRouteParser(),
+        create: (_) => PostBloc(repository),
-        routerDelegate: _appRouter.delegate(),
+        child: MaterialApp.router(
-        theme: ThemeData.light(),
+          routeInformationParser: _appRouter.defaultRouteParser(),
+          routerDelegate: _appRouter.delegate(),
+          theme: ThemeData.light(),
+        ),
       ),
     );
   }

examples/postly/lib/di/app_module.dart

@@ -1,6 +1,9 @@
 import 'package:cherrypick_annotations/cherrypick_annotations.dart';
 import 'package:dio/dio.dart';
 import 'package:cherrypick/cherrypick.dart';
+import 'package:talker_dio_logger/talker_dio_logger_interceptor.dart';
+import 'package:talker_dio_logger/talker_dio_logger_settings.dart';
+import 'package:talker_flutter/talker_flutter.dart';
 import '../data/network/json_placeholder_api.dart';
 import '../data/post_repository_impl.dart';
 import '../domain/repository/post_repository.dart';
@@ -9,6 +12,20 @@ part 'app_module.module.cherrypick.g.dart';
 
 @module()
 abstract class AppModule extends Module {
+  @provide()
+  @singleton()
+  TalkerDioLoggerSettings talkerDioLoggerSettings() => TalkerDioLoggerSettings(
+        printRequestHeaders: true,
+        printResponseHeaders: true,
+        printResponseMessage: true,
+      );
+
+  @provide()
+  @singleton()
+  TalkerDioLogger talkerDioLogger(
+          Talker talker, TalkerDioLoggerSettings settings) =>
+      TalkerDioLogger(talker: talker, settings: settings);
+
   @instance()
   int timeout() => 1000;
 
@@ -35,8 +52,8 @@ abstract class AppModule extends Module {
   @provide()
   @singleton()
   @named('dio')
-  Dio dio(@named('baseUrl') String baseUrl) =>
+  Dio dio(@named('baseUrl') String baseUrl, TalkerDioLogger logger) =>
-      Dio(BaseOptions(baseUrl: baseUrl));
+      Dio(BaseOptions(baseUrl: baseUrl))..interceptors.add(logger);
 
   @provide()
   @singleton()

examples/postly/lib/di/core_module.dart

@@ -0,0 +1,13 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'package:talker_flutter/talker_flutter.dart';
+
+class CoreModule extends Module {
+  final Talker _talker;
+
+  CoreModule({required Talker talker}) : _talker = talker;
+
+  @override
+  void builder(Scope currentScope) {
+    bind<Talker>().toProvide(() => _talker).singleton();
+  }
+}

examples/postly/lib/main.dart

@@ -1,18 +1,32 @@
 import 'package:cherrypick/cherrypick.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:postly/app.dart';
+import 'package:postly/di/core_module.dart';
+import 'package:talker_bloc_logger/talker_bloc_logger_observer.dart';
+import 'package:talker_flutter/talker_flutter.dart';
 import 'di/app_module.dart';
+import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';
 
 void main() {
+  final talker = Talker();
+  final talkerLogger = TalkerCherryPickObserver(talker);
+
+  Bloc.observer = TalkerBlocObserver(talker: talker);
+
+  CherryPick.setGlobalObserver(talkerLogger);
   // Включаем cycle-detection только в debug/test
   if (kDebugMode) {
-    CherryPick.setGlobalLogger(PrintLogger());
     CherryPick.enableGlobalCycleDetection();
     CherryPick.enableGlobalCrossScopeCycleDetection();
   }
 
   // Используем safe root scope для гарантии защиты
-  CherryPick.openRootScope().installModules([$AppModule()]);
+  CherryPick.openRootScope()
-  runApp(MyApp());
+      .installModules([CoreModule(talker: talker), $AppModule()]);
+
+  runApp(MyApp(
+    talker: talker,
+  ));
 }

examples/postly/lib/presentation/pages/logs_page.dart

@@ -0,0 +1,15 @@
+import 'package:auto_route/auto_route.dart';
+import 'package:flutter/material.dart';
+import 'package:talker_flutter/talker_flutter.dart';
+import '../../app.dart';
+
+@RoutePage()
+class LogsPage extends StatelessWidget {
+  const LogsPage({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final talker = TalkerProvider.of(context);
+    return TalkerScreen(talker: talker);
+  }
+}

examples/postly/lib/presentation/pages/posts_page.dart

@@ -15,7 +15,18 @@ class PostsPage extends StatelessWidget {
       create: (context) =>
           context.read<PostBloc>()..add(const PostEvent.fetchAll()),
       child: Scaffold(
-        appBar: AppBar(title: const Text('Posts')),
+        appBar: AppBar(
+          title: const Text('Posts'),
+          actions: [
+            IconButton(
+              icon: const Icon(Icons.bug_report),
+              tooltip: 'Open logs',
+              onPressed: () {
+                AutoRouter.of(context).push(const LogsRoute());
+              },
+            ),
+          ],
+        ),
         body: BlocBuilder<PostBloc, PostState>(
           builder: (context, state) {
             return state.when(

examples/postly/lib/router/app_router.dart

@@ -1,5 +1,4 @@
 import 'package:auto_route/auto_route.dart';
-
 import 'app_router.gr.dart';
 
 @AutoRouterConfig()
@@ -8,5 +7,6 @@ class AppRouter extends RootStackRouter {
   List<AutoRoute> get routes => [
         AutoRoute(page: PostsRoute.page, initial: true),
         AutoRoute(page: PostDetailsRoute.page),
+        AutoRoute(page: LogsRoute.page),
       ];
 }

examples/postly/pubspec.lock

@@ -17,6 +17,22 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "7.4.5"
+  ansi_styles:
+    dependency: transitive
+    description:
+      name: ansi_styles
+      sha256: "9c656cc12b3c27b17dd982b2cc5c0cfdfbdabd7bc8f3ae5e8542d9867b47ce8a"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.2+1"
+  ansicolor:
+    dependency: transitive
+    description:
+      name: ansicolor
+      sha256: "50e982d500bc863e1d703448afdbf9e5a72eb48840a4f766fa361ffd6877055f"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.0.3"
   args:
     dependency: transitive
     description:
@@ -42,7 +58,7 @@ packages:
     source: hosted
     version: "9.3.0+1"
   auto_route_generator:
-    dependency: "direct dev"
+    dependency: "direct main"
     description:
       name: auto_route_generator
       sha256: c2e359d8932986d4d1bcad7a428143f81384ce10fef8d4aa5bc29e1f83766a46
@@ -98,7 +114,7 @@ packages:
     source: hosted
     version: "2.4.4"
   build_runner:
-    dependency: "direct dev"
+    dependency: "direct main"
     description:
       name: build_runner
       sha256: "058fe9dce1de7d69c4b84fada934df3e0153dd000758c4d65964d0166779aa99"
@@ -137,6 +153,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.4.0"
+  charcode:
+    dependency: transitive
+    description:
+      name: charcode
+      sha256: fb0f1107cac15a5ea6ef0a6ef71a807b9e4267c713bb93e00e92d737cc8dbd8a
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.0"
   checked_yaml:
     dependency: transitive
     description:
@@ -151,21 +175,37 @@ packages:
       path: "../../cherrypick"
       relative: true
     source: path
-    version: "3.0.0-dev.5"
+    version: "3.0.0-dev.9"
   cherrypick_annotations:
     dependency: "direct main"
     description:
       path: "../../cherrypick_annotations"
       relative: true
     source: path
-    version: "1.1.0"
+    version: "1.1.2-dev.0"
   cherrypick_generator:
-    dependency: "direct dev"
+    dependency: "direct main"
     description:
       path: "../../cherrypick_generator"
       relative: true
     source: path
-    version: "1.1.0"
+    version: "2.0.0-dev.0"
+  cli_launcher:
+    dependency: transitive
+    description:
+      name: cli_launcher
+      sha256: "67d89e0a1c07b103d1253f6b953a43d3f502ee36805c8cfc21196282c9ddf177"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.2"
+  cli_util:
+    dependency: transitive
+    description:
+      name: cli_util
+      sha256: ff6785f7e9e3c38ac98b2fb035701789de90154024a75b6cb926445e83197d1c
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.4.2"
   clock:
     dependency: transitive
     description:
@@ -190,6 +230,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.19.1"
+  conventional_commit:
+    dependency: transitive
+    description:
+      name: conventional_commit
+      sha256: fad254feb6fb8eace2be18855176b0a4b97e0d50e416ff0fe590d5ba83735d34
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.6.1"
   convert:
     dependency: transitive
     description:
@@ -198,6 +246,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "3.1.2"
+  cross_file:
+    dependency: transitive
+    description:
+      name: cross_file
+      sha256: "7caf6a750a0c04effbb52a676dce9a4a592e10ad35c34d6d2d0e4811160d5670"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.4+2"
   crypto:
     dependency: transitive
     description:
@@ -254,6 +310,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.3.2"
+  ffi:
+    dependency: transitive
+    description:
+      name: ffi
+      sha256: "289279317b4b16eb2bb7e271abccd4bf84ec9bdcbe999e278a94b804f5630418"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.4"
   file:
     dependency: transitive
     description:
@@ -284,7 +348,7 @@ packages:
     source: hosted
     version: "9.1.1"
   flutter_lints:
-    dependency: "direct dev"
+    dependency: "direct main"
     description:
       name: flutter_lints
       sha256: "5398f14efa795ffb7a33e9b6a08798b26a180edac4ad7db3f231e40f82ce11e1"
@@ -292,12 +356,17 @@ packages:
     source: hosted
     version: "5.0.0"
   flutter_test:
-    dependency: "direct dev"
+    dependency: "direct main"
+    description: flutter
+    source: sdk
+    version: "0.0.0"
+  flutter_web_plugins:
+    dependency: transitive
     description: flutter
     source: sdk
     version: "0.0.0"
   freezed:
-    dependency: "direct dev"
+    dependency: "direct main"
     description:
       name: freezed
       sha256: "59a584c24b3acdc5250bb856d0d3e9c0b798ed14a4af1ddb7dc1c7b41df91c9c"
@@ -336,6 +405,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.3.2"
+  group_button:
+    dependency: transitive
+    description:
+      name: group_button
+      sha256: "0610fcf28ed122bfb4b410fce161a390f7f2531d55d1d65c5375982001415940"
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.3.4"
   http:
     dependency: transitive
     description:
@@ -360,6 +437,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "4.0.2"
+  intl:
+    dependency: transitive
+    description:
+      name: intl
+      sha256: d6f56758b7d3014a48af9701c085700aac781a92a87a62b1333b46d8879661cf
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.19.0"
   io:
     dependency: transitive
     description:
@@ -385,7 +470,7 @@ packages:
     source: hosted
     version: "4.9.0"
   json_serializable:
-    dependency: "direct dev"
+    dependency: "direct main"
     description:
       name: json_serializable
       sha256: c50ef5fc083d5b5e12eef489503ba3bf5ccc899e487d691584699b4bdefeea8c
@@ -448,6 +533,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "0.11.1"
+  melos:
+    dependency: "direct dev"
+    description:
+      name: melos
+      sha256: "3f3ab3f902843d1e5a1b1a4dd39a4aca8ba1056f2d32fd8995210fa2843f646f"
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.3.2"
   meta:
     dependency: transitive
     description:
@@ -464,6 +557,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.0.0"
+  mustache_template:
+    dependency: transitive
+    description:
+      name: mustache_template
+      sha256: a46e26f91445bfb0b60519be280555b06792460b27b19e2b19ad5b9740df5d1c
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.0.0"
   nested:
     dependency: transitive
     description:
@@ -488,6 +589,54 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.9.1"
+  path_provider:
+    dependency: transitive
+    description:
+      name: path_provider
+      sha256: "50c5dd5b6e1aaf6fb3a78b33f6aa3afca52bf903a8a5298f53101fdaee55bbcd"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.5"
+  path_provider_android:
+    dependency: transitive
+    description:
+      name: path_provider_android
+      sha256: d0d310befe2c8ab9e7f393288ccbb11b60c019c6b5afc21973eeee4dda2b35e9
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.17"
+  path_provider_foundation:
+    dependency: transitive
+    description:
+      name: path_provider_foundation
+      sha256: "4843174df4d288f5e29185bd6e72a6fbdf5a4a4602717eed565497429f179942"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.4.1"
+  path_provider_linux:
+    dependency: transitive
+    description:
+      name: path_provider_linux
+      sha256: f7a1fe3a634fe7734c8d3f2766ad746ae2a2884abe22e241a8b301bf5cac3279
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.1"
+  path_provider_platform_interface:
+    dependency: transitive
+    description:
+      name: path_provider_platform_interface
+      sha256: "88f5779f72ba699763fa3a3b06aa4bf6de76c8e5de842cf6f29e2e06476c2334"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.2"
+  path_provider_windows:
+    dependency: transitive
+    description:
+      name: path_provider_windows
+      sha256: bd6f00dbd873bfb70d0761682da2b3a2c2fccc2b9e84c495821639601d81afe7
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.3.0"
   petitparser:
     dependency: transitive
     description:
@@ -496,6 +645,22 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "6.0.2"
+  platform:
+    dependency: transitive
+    description:
+      name: platform
+      sha256: "5d6b1b0036a5f331ebc77c850ebc8506cbc1e9416c27e59b439f917a902a4984"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.6"
+  plugin_platform_interface:
+    dependency: transitive
+    description:
+      name: plugin_platform_interface
+      sha256: "4820fbfdb9478b1ebae27888254d445073732dae3d6ea81f0b7e06d5dedc3f02"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.8"
   pool:
     dependency: transitive
     description:
@@ -504,6 +669,22 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.5.1"
+  process:
+    dependency: transitive
+    description:
+      name: process
+      sha256: c6248e4526673988586e8c00bb22a49210c258dc91df5227d5da9748ecf79744
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.0.5"
+  prompts:
+    dependency: transitive
+    description:
+      name: prompts
+      sha256: "3773b845e85a849f01e793c4fc18a45d52d7783b4cb6c0569fad19f9d0a774a1"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.0.0"
   protobuf:
     dependency: transitive
     description:
@@ -528,6 +709,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.2.0"
+  pub_updater:
+    dependency: transitive
+    description:
+      name: pub_updater
+      sha256: "54e8dc865349059ebe7f163d6acce7c89eb958b8047e6d6e80ce93b13d7c9e60"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.4.0"
   pubspec_parse:
     dependency: transitive
     description:
@@ -545,13 +734,29 @@ packages:
     source: hosted
     version: "4.4.2"
   retrofit_generator:
-    dependency: "direct dev"
+    dependency: "direct main"
     description:
       name: retrofit_generator
       sha256: "65d28d3a7b4db485f1c73fee8ee32f552ef23ee4ecb68ba491f39d80b73bdcbf"
       url: "https://pub.dev"
     source: hosted
     version: "9.2.0"
+  share_plus:
+    dependency: transitive
+    description:
+      name: share_plus
+      sha256: b2961506569e28948d75ec346c28775bb111986bb69dc6a20754a457e3d97fa0
+      url: "https://pub.dev"
+    source: hosted
+    version: "11.0.0"
+  share_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: share_plus_platform_interface
+      sha256: "1032d392bc5d2095a77447a805aa3f804d2ae6a4d5eef5e6ebb3bd94c1bc19ef"
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.0.0"
   shelf:
     dependency: transitive
     description:
@@ -597,6 +802,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.10.1"
+  sprintf:
+    dependency: transitive
+    description:
+      name: sprintf
+      sha256: "1fc9ffe69d4df602376b52949af107d8f5703b77cda567c4d7d86a0693120f23"
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.0.0"
   stack_trace:
     dependency: transitive
     description:
@@ -629,6 +842,53 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.4.1"
+  talker:
+    dependency: transitive
+    description:
+      name: talker
+      sha256: "028a753874d98df39f210cb74f0ee09a0a95e28f8bc2dc975c3c328e24fde23d"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.9.3"
+  talker_bloc_logger:
+    dependency: "direct main"
+    description:
+      name: talker_bloc_logger
+      sha256: cf1e3b1d70f9a47e061288f0d230ba0e04a0f6394629d5df1c7b0933b236e397
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.9.3"
+  talker_cherrypick_logger:
+    dependency: "direct main"
+    description:
+      path: "../../talker_cherrypick_logger"
+      relative: true
+    source: path
+    version: "1.1.0-dev.3"
+  talker_dio_logger:
+    dependency: "direct main"
+    description:
+      name: talker_dio_logger
+      sha256: dcf784f1841e248c270ef741f8a07ca9cf562c6424ee43fc6e598c4eb7f18238
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.9.3"
+  talker_flutter:
+    dependency: "direct main"
+    description:
+      name: talker_flutter
+      sha256: "2cfee6661277d415a895b6258ecb0bf80d7b564e91ea7e769fc6d0f970a01c09"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.9.3"
+  talker_logger:
+    dependency: transitive
+    description:
+      name: talker_logger
+      sha256: "778ec673f1b71a6516e5576ae8d90ea23bbbcf9f405a97cc30e8ccdc33e26d27"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.9.3"
   term_glyph:
     dependency: transitive
     description:
@@ -661,6 +921,46 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.4.0"
+  url_launcher_linux:
+    dependency: transitive
+    description:
+      name: url_launcher_linux
+      sha256: "4e9ba368772369e3e08f231d2301b4ef72b9ff87c31192ef471b380ef29a4935"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.2.1"
+  url_launcher_platform_interface:
+    dependency: transitive
+    description:
+      name: url_launcher_platform_interface
+      sha256: "552f8a1e663569be95a8190206a38187b531910283c3e982193e4f2733f01029"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.3.2"
+  url_launcher_web:
+    dependency: transitive
+    description:
+      name: url_launcher_web
+      sha256: "4bd2b7b4dc4d4d0b94e5babfffbca8eac1a126c7f3d6ecbc1a11013faa3abba2"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.4.1"
+  url_launcher_windows:
+    dependency: transitive
+    description:
+      name: url_launcher_windows
+      sha256: "3284b6d2ac454cf34f114e1d3319866fdd1e19cdc329999057e44ffe936cfa77"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.4"
+  uuid:
+    dependency: transitive
+    description:
+      name: uuid
+      sha256: a5be9ef6618a7ac1e964353ef476418026db906c4facdedaa299b7a2e71690ff
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.5.1"
   vector_math:
     dependency: transitive
     description:
@@ -709,6 +1009,22 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "3.0.3"
+  win32:
+    dependency: transitive
+    description:
+      name: win32
+      sha256: "329edf97fdd893e0f1e3b9e88d6a0e627128cc17cc316a8d67fda8f1451178ba"
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.13.0"
+  xdg_directories:
+    dependency: transitive
+    description:
+      name: xdg_directories
+      sha256: "7a3f37b05d989967cdddcbb571f1ea834867ae2faa29725fd085180e0883aa15"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.0"
   xml:
     dependency: transitive
     description:
@@ -725,6 +1041,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "3.1.3"
+  yaml_edit:
+    dependency: transitive
+    description:
+      name: yaml_edit
+      sha256: fb38626579fb345ad00e674e2af3a5c9b0cc4b9bfb8fd7f7ff322c7c9e62aef5
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.2"
 sdks:
   dart: ">=3.7.0 <4.0.0"
-  flutter: ">=3.18.0-18.0.pre.54"
+  flutter: ">=3.27.0"

examples/postly/pubspec.yaml

@@ -24,9 +24,12 @@ dependencies:
   flutter_bloc: ^9.1.1
   auto_route: ^9.3.0+1
 
+
   cupertino_icons: ^1.0.8
 
-dev_dependencies:
+  talker_flutter: ^4.9.3
+  talker_cherrypick_logger:
+    path: ../../talker_cherrypick_logger
   flutter_test:
     sdk: flutter
 
@@ -40,7 +43,11 @@ dev_dependencies:
   freezed: ^2.5.8
   json_serializable: ^6.9.0
   auto_route_generator: ^9.0.0
+  talker_dio_logger: ^4.9.3
+  talker_bloc_logger: ^4.9.3
 
 flutter:
 
   uses-material-design: true
+dev_dependencies:
+  melos: ^6.3.2

melos.yaml

@@ -8,6 +8,7 @@ packages:
   - cherrypick_flutter
   - cherrypick_annotations
   - cherrypick_generator
+  - talker_cherrypick_logger
   - examples/client_app
   - examples/postly
 

talker_cherrypick_logger/.gitignore

@@ -0,0 +1,26 @@
+# See https://www.dartlang.org/guides/libraries/private-files
+
+# Files and directories created by pub
+.dart_tool/
+.packages
+build/
+# If you're building an application, you may want to check-in your pubspec.lock
+pubspec.lock
+
+# Directory created by dartdoc
+# If you don't generate documentation locally you can remove this line.
+doc/api/
+
+# Avoid committing generated Javascript files:
+*.dart.js
+*.info.json      # Produced by the --dump-info flag.
+*.js             # When generated by dart2js. Don't specify *.js if your
+                 # project includes source files written in JavaScript.
+*.js_
+*.js.deps
+*.js.map
+
+# FVM Version Cache
+.fvm/
+
+pubspec_overrides.yaml

talker_cherrypick_logger/CHANGELOG.md

@@ -0,0 +1,23 @@
+## 1.1.0-dev.5
+
+ - **DOCS**(pub): update homepage and documentation URLs in pubspec.yaml to new official site.
+
+## 1.1.0-dev.4
+
+ - **DOCS**(readme): update install instructions to use pub.dev as default method and remove obsolete git example.
+
+## 1.1.0-dev.3
+
+## 1.1.0-dev.2
+
+ - Bump "talker_cherrypick_logger" to `1.1.0-dev.2`.
+
+## 1.1.0-dev.0
+
+ - **FEAT**(logging): add talker_dio_logger and talker_bloc_logger integration, improve cherrypick logger structure, add UI log screen for DI and network/bloc debug.
+ - **DOCS**: add full English documentation and usage guide to README.md.
+ - **DOCS**: add detailed English documentation and usage examples for TalkerCherryPickObserver.
+
+## 1.0.0
+
+- Initial version.

talker_cherrypick_logger/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

talker_cherrypick_logger/README.md

@@ -0,0 +1,121 @@
+# talker_cherrypick_logger
+
+An integration package that allows you to log [CherryPick](https://github.com/pese-dot-work/cherrypick) Dependency Injection (DI) container events using the [Talker](https://pub.dev/packages/talker) logging system.  
+All CherryPick lifecycle events, instance creations, cache operations, module activities, cycles, and errors are routed directly to your Talker logger for easy debugging and advanced diagnostics.
+
+---
+
+## Features
+
+- **Automatic DI container logging:**  
+  All core CherryPick events (instance creation/disposal, cache hits/misses, module install/removal, scopes, cycles, errors) are logged through Talker.
+- **Flexible log levels:**  
+  Each event uses the appropriate Talker log level (`info`, `warning`, `verbose`, `handle` for errors).
+- **Works with any Talker setup:**  
+  No extra dependencies required except Talker and CherryPick.
+- **Improves debugging and DI transparency** in both development and production.
+
+---
+
+## Getting started
+
+### 1. Add dependencies
+
+Install the package **from [pub.dev](https://pub.dev/packages/talker_cherrypick_logger)**:
+
+In your `pubspec.yaml`:
+```yaml
+dependencies:
+  cherrypick: ^latest
+  talker: ^latest
+  talker_cherrypick_logger: ^latest
+```
+
+### 2. Import the package
+```dart
+import 'package:talker/talker.dart';
+import 'package:cherrypick/cherrypick.dart';
+import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';
+```
+
+---
+
+## Usage
+
+### Basic integration
+
+1. **Create a Talker instance** (optionally customize Talker as you wish):
+    ```dart
+    final talker = Talker();
+    ```
+
+2. **Create the observer and pass it to CherryPick:**
+    ```dart
+    final observer = TalkerCherryPickObserver(talker);
+
+    // On DI setup, pass observer when opening (or re-opening) root or any custom scope
+    CherryPick.openRootScope(observer: observer);
+    ```
+
+3. **Now all DI events appear in your Talker logs!**
+
+#### Example log output
+
+- `[binding][CherryPick] MyService — MyServiceImpl (scope: root)`
+- `[create][CherryPick] MyService — MyServiceImpl => Instance(...) (scope: root)`
+- `[cache hit][CherryPick] MyService — MyServiceImpl (scope: root)`
+- `[cycle][CherryPick] Detected: A -> B -> C -> A (scope: root)`
+- `[error][CherryPick] Failed to resolve dependency`
+- `[diagnostic][CherryPick] Cache cleared`
+
+#### How it works
+
+`TalkerCherryPickObserver` implements `CherryPickObserver` and routes all methods/events to Talker:
+- Regular events: `.info()`  
+- DI Warnings and cycles: `.warning()`  
+- Diagnostics: `.verbose()`  
+- Errors: `.handle()` (so they are visible in Talker error console, with stack trace)
+
+---
+
+## Extended example
+
+```dart
+import 'package:cherrypick/cherrypick.dart';
+import 'package:talker/talker.dart';
+import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';
+
+void main() {
+  final talker = Talker();
+  final observer = TalkerCherryPickObserver(talker);
+
+  // Optionally: customize Talker output or filtering
+  // talker.settings.logLevel = TalkerLogLevel.debug;
+
+  CherryPick.openRootScope(observer: observer);
+
+  // ...setup your DI modules as usual
+  // All container events will appear in Talker logs for easy debugging!
+}
+```
+
+---
+
+## Additional information
+
+- This package is especially useful for debugging large or layered projects using CherryPick.
+- For advanced Talker configurations (UI, outputs to remote, filtering), see the [Talker documentation](https://pub.dev/packages/talker).
+- This package does **not** interfere with DI graph construction or your app's behavior — it's purely diagnostic.
+- For questions or issues, open an issue on the main [cherrypick repository](https://github.com/pese-dot-work/cherrypick).
+
+---
+
+## Contributing
+
+Feel free to contribute improvements or report bugs via pull requests or issues!
+
+---
+
+## License
+
+See [LICENSE](LICENSE) for details.

talker_cherrypick_logger/analysis_options.yaml

@@ -0,0 +1,30 @@
+# 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
+
+# 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

talker_cherrypick_logger/example/talker_cherrypick_logger_example.dart

@@ -0,0 +1,17 @@
+import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';
+import 'package:talker/talker.dart';
+
+void main() {
+  final talker = Talker();
+  final logger = TalkerCherryPickObserver(talker);
+
+  logger.onDiagnostic('Hello from CherryPickLogger!');
+  logger.onWarning('Something might be wrong...');
+  logger.onError('Oops! An error occurred', Exception('Test error'), null);
+
+  // Вывод всех логов
+  print('\nВсе сообщения логирования через Talker:');
+  for (final log in talker.history) {
+    print(log); // Пример, либо log.toString(), либо log.message
+  }
+}

talker_cherrypick_logger/lib/src/talker_cherrypick_observer.dart

@@ -0,0 +1,149 @@
+//
+// Copyright 2021 Sergey Penkovsky (sergey.penkovsky@gmail.com)
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//      https://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import 'package:cherrypick/cherrypick.dart';
+import 'package:talker/talker.dart';
+
+/// An implementation of [CherryPickObserver] that logs all DI container events
+/// through the [Talker] logging system.
+///
+/// This observer allows you to automatically route all important events from the
+/// CherryPick DI container (such as instance creation, cache hits, errors, module install,
+/// scope lifecycle events, and more) directly to your Talker logger. It is useful for
+/// debugging, monitoring, and analytics.
+///
+/// ## Example usage
+/// ```dart
+/// import 'package:talker/talker.dart';
+/// import 'package:cherrypick/cherrypick.dart';
+/// import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';
+///
+/// final talker = Talker();
+/// final observer = TalkerCherryPickObserver(talker);
+///
+/// // Pass the observer to your CherryPick root scope (or any scope)
+/// CherryPick.openRootScope(observer: observer);
+///
+/// // Now all DI container events will be logged with Talker
+/// ```
+///
+/// ## Logged event examples
+/// - "[binding][CherryPick] MyService — MyServiceImpl (scope: root)"
+/// - "[create][CherryPick] MyService — MyServiceImpl => Instance(...) (scope: root)"
+/// - "[cache hit][CherryPick] MyService — MyServiceImpl (scope: root)"
+/// - "[cycle][CherryPick] Detected: A -> B -> C -> A (scope: root)"
+///
+/// ## Log levels mapping
+/// - `info`: regular events (registered, resolved, created, disposed, modules, scopes, cache hits/misses)
+/// - `warning`: cycles, cherry pick warnings
+/// - `verbose`: diagnostics
+/// - `handle`: errors (includes error object/stack)
+class TalkerCherryPickObserver implements CherryPickObserver {
+  /// The target [Talker] instance to send logs to.
+  final Talker talker;
+
+  /// Creates a [TalkerCherryPickObserver] that routes CherryPick DI events into the given [Talker] logger.
+  TalkerCherryPickObserver(this.talker);
+
+  /// Called when a binding (dependency mapping) is registered in the DI container.
+  @override
+  void onBindingRegistered(String name, Type type, {String? scopeName}) {
+    talker.info('[binding][CherryPick] $name — $type (scope: $scopeName)');
+  }
+
+  /// Called when an instance is requested (before creation or retrieval).
+  @override
+  void onInstanceRequested(String name, Type type, {String? scopeName}) {
+    talker.info('[request][CherryPick] $name — $type (scope: $scopeName)');
+  }
+
+  /// Called when a new instance is created.
+  @override
+  void onInstanceCreated(String name, Type type, Object instance,
+      {String? scopeName}) {
+    talker.info(
+        '[create][CherryPick] $name — $type => $instance (scope: $scopeName)');
+  }
+
+  /// Called when an instance is disposed.
+  @override
+  void onInstanceDisposed(String name, Type type, Object instance,
+      {String? scopeName}) {
+    talker.info(
+        '[dispose][CherryPick] $name — $type => $instance (scope: $scopeName)');
+  }
+
+  /// Called when modules are installed.
+  @override
+  void onModulesInstalled(List<String> modules, {String? scopeName}) {
+    talker.info(
+        '[modules installed][CherryPick] ${modules.join(', ')} (scope: $scopeName)');
+  }
+
+  /// Called when modules are removed.
+  @override
+  void onModulesRemoved(List<String> modules, {String? scopeName}) {
+    talker.info(
+        '[modules removed][CherryPick] ${modules.join(', ')} (scope: $scopeName)');
+  }
+
+  /// Called when a DI scope is opened.
+  @override
+  void onScopeOpened(String name) {
+    talker.info('[scope opened][CherryPick] $name');
+  }
+
+  /// Called when a DI scope is closed.
+  @override
+  void onScopeClosed(String name) {
+    talker.info('[scope closed][CherryPick] $name');
+  }
+
+  /// Called if the DI container detects a cycle in the dependency graph.
+  @override
+  void onCycleDetected(List<String> chain, {String? scopeName}) {
+    talker.warning(
+        '[cycle][CherryPick] Detected: ${chain.join(' -> ')}${scopeName != null ? ' (scope: $scopeName)' : ''}');
+  }
+
+  /// Called when an instance is found in the cache.
+  @override
+  void onCacheHit(String name, Type type, {String? scopeName}) {
+    talker.info('[cache hit][CherryPick] $name — $type (scope: $scopeName)');
+  }
+
+  /// Called when an instance is NOT found in the cache and will be created.
+  @override
+  void onCacheMiss(String name, Type type, {String? scopeName}) {
+    talker.info('[cache miss][CherryPick] $name — $type (scope: $scopeName)');
+  }
+
+  /// Called for generic diagnostic/debug events.
+  @override
+  void onDiagnostic(String message, {Object? details}) {
+    talker.verbose('[diagnostic][CherryPick] $message ${details ?? ''}');
+  }
+
+  /// Called for non-fatal DI container warnings.
+  @override
+  void onWarning(String message, {Object? details}) {
+    talker.warning('[warn][CherryPick] $message ${details ?? ''}');
+  }
+
+  /// Called for error events with optional stack trace.
+  @override
+  void onError(String message, Object? error, StackTrace? stackTrace) {
+    talker.handle(error ?? '[CherryPick] $message', stackTrace,
+        '[error][CherryPick] $message');
+  }
+}

talker_cherrypick_logger/lib/talker_cherrypick_logger.dart

@@ -0,0 +1,18 @@
+//
+// Copyright 2021 Sergey Penkovsky (sergey.penkovsky@gmail.com)
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//      https://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+library;
+
+export 'src/talker_cherrypick_observer.dart';
+
+// TODO: Export any libraries intended for clients of this package.

talker_cherrypick_logger/pubspec.yaml

@@ -0,0 +1,26 @@
+name: talker_cherrypick_logger
+description: A Talker logger integration for CherryPick DI to observe and log DI events and errors.
+version: 1.1.0-dev.5
+homepage: https://cherrypick-di.dev/
+documentation: https://cherrypick-di.dev/docs/intro
+repository: https://github.com/pese-git/cherrypick
+issue_tracker: https://github.com/pese-git/cherrypick/issues
+
+topics:
+  - cherrypick
+  - state
+  - logging
+  - log
+  
+environment:
+  sdk: ">=3.5.2 <4.0.0"
+
+# Add regular dependencies here.
+dependencies:
+  talker: ^4.9.3
+  cherrypick: ^3.0.0-dev.10
+
+
+dev_dependencies:
+  lints: ^5.0.0
+  test: ^1.24.0

talker_cherrypick_logger/test/talker_cherrypick_logger_test.dart

@@ -0,0 +1,47 @@
+import 'package:test/test.dart';
+import 'package:talker/talker.dart';
+import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';
+
+void main() {
+  group('TalkerCherryPickObserver', () {
+    late Talker talker;
+    late TalkerCherryPickObserver observer;
+
+    setUp(() {
+      talker = Talker();
+      observer = TalkerCherryPickObserver(talker);
+    });
+
+    test('onInstanceRequested logs info', () {
+      observer.onInstanceRequested('A', String, scopeName: 'test');
+      final log = talker.history.last;
+      expect(log.message,
+          contains('[request][CherryPick] A — String (scope: test)'));
+    });
+
+    test('onCycleDetected logs warning', () {
+      observer.onCycleDetected(['A', 'B'], scopeName: 's');
+      final log = talker.history.last;
+      expect(log.message, contains('[cycle][CherryPick] Detected'));
+      //expect(log.level, TalkerLogLevel.warning);
+    });
+
+    test('onError calls handle', () {
+      final error = Exception('fail');
+      final stack = StackTrace.current;
+      observer.onError('Oops', error, stack);
+      final log = talker.history.last;
+      expect(log.message, contains('[error][CherryPick] Oops'));
+      expect(log.exception, error);
+      expect(log.stackTrace, stack);
+    });
+
+    test('onDiagnostic logs verbose', () {
+      observer.onDiagnostic('hello', details: 123);
+      final log = talker.history.last;
+      //expect(log.level, TalkerLogLevel.verbose);
+      expect(log.message, contains('hello'));
+      expect(log.message, contains('123'));
+    });
+  });
+}