feat(benchmark_di): add resolve phases, eager/lazy scenarios, and adapter parity

benchmark_di/lib/benchmarks/universal_chain_async_benchmark.dart

@@ -25,7 +25,11 @@ class UniversalChainAsyncBenchmark<TContainer> extends AsyncBenchmarkBase {
       bindingMode: mode,
       scenario: UniversalScenario.asyncChain,
     ));
+  }
+
+  Future<void> prewarm() async {
     await di.waitForAsyncReady();
+    await run();
   }
 
   @override

benchmark_di/lib/benchmarks/universal_chain_benchmark.dart

@@ -50,7 +50,14 @@ class UniversalChainBenchmark<TContainer> extends BenchmarkBase {
   }
 
   @override
-  void teardown() => _di.teardown();
+  void teardown() {
+    _childDi?.teardown();
+    _di.teardown();
+  }
+
+  void prewarm() {
+    run();
+  }
 
   @override
   void run() {
@@ -59,11 +66,7 @@ class UniversalChainBenchmark<TContainer> extends BenchmarkBase {
         _di.resolve<UniversalService>();
         break;
       case UniversalScenario.named:
-        if (_di.runtimeType.toString().contains('GetItAdapter')) {
         _di.resolve<UniversalService>(named: 'impl2');
-        } else {
-          _di.resolve<UniversalService>(named: 'impl2');
-        }
         break;
       case UniversalScenario.chain:
         final serviceName = '${chainCount}_$nestingDepth';

benchmark_di/lib/cli/benchmark_cli.dart

@@ -31,9 +31,16 @@ class BenchmarkCliRunner {
   Future<void> run(List<String> args) async {
     final config = parseBenchmarkCli(args);
     final results = <Map<String, dynamic>>[];
+    // DI implementations that do not support async scenarios
+    const asyncUnsupported = {'kiwi', 'yx_scope'};
+    for (final phase in config.phases) {
       for (final bench in config.benchesToRun) {
         final scenario = toScenario(bench);
         final mode = toMode(bench);
+        if (asyncUnsupported.contains(config.di) &&
+            scenario == UniversalScenario.asyncChain) {
+          continue; // Skip async benchmarks for DI that does not support them
+        }
         for (final c in config.chainCounts) {
           for (final d in config.nestDepths) {
             BenchmarkResult benchResult;
@@ -50,6 +57,7 @@ class BenchmarkCliRunner {
                   benchmark: benchAsync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               } else {
                 final benchSync = UniversalChainBenchmark<GetIt>(
@@ -63,12 +71,12 @@ class BenchmarkCliRunner {
                   benchmark: benchSync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               }
             } else if (config.di == 'kiwi') {
               final di = KiwiAdapter();
               if (scenario == UniversalScenario.asyncChain) {
-              // UnsupportedError будет выброшен адаптером, но если дойдёт — вызывать async benchmark
                 final benchAsync = UniversalChainAsyncBenchmark<KiwiContainer>(
                   di,
                   chainCount: c,
@@ -79,6 +87,7 @@ class BenchmarkCliRunner {
                   benchmark: benchAsync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               } else {
                 final benchSync = UniversalChainBenchmark<KiwiContainer>(
@@ -92,6 +101,7 @@ class BenchmarkCliRunner {
                   benchmark: benchSync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               }
             } else if (config.di == 'riverpod') {
@@ -108,6 +118,7 @@ class BenchmarkCliRunner {
                   benchmark: benchAsync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               } else {
                 final benchSync = UniversalChainBenchmark<
@@ -122,6 +133,7 @@ class BenchmarkCliRunner {
                   benchmark: benchSync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               }
             } else if (config.di == 'yx_scope') {
@@ -138,6 +150,7 @@ class BenchmarkCliRunner {
                   benchmark: benchAsync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               } else {
                 final benchSync =
@@ -152,6 +165,7 @@ class BenchmarkCliRunner {
                   benchmark: benchSync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               }
             } else {
@@ -167,6 +181,7 @@ class BenchmarkCliRunner {
                   benchmark: benchAsync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               } else {
                 final benchSync = UniversalChainBenchmark<Scope>(
@@ -180,22 +195,27 @@ class BenchmarkCliRunner {
                   benchmark: benchSync,
                   warmups: config.warmups,
                   repeats: config.repeats,
+                  phase: phase,
                 );
               }
             }
             final timings = benchResult.timings;
+            if (timings.isEmpty) continue; // skip failed scenarios
             timings.sort();
-          var mean = timings.reduce((a, b) => a + b) / timings.length;
+            final count = timings.length;
-          var median = timings[timings.length ~/ 2];
+            final mean = timings.reduce((a, b) => a + b) / count;
-          var minVal = timings.first;
+            final median = count.isOdd
-          var maxVal = timings.last;
+                ? timings[count ~/ 2]
-          var stddev = timings.isEmpty
+                : (timings[count ~/ 2 - 1] + timings[count ~/ 2]) / 2;
-              ? 0
+            final minVal = timings.first;
-              : sqrt(
+            final maxVal = timings.last;
-                  timings.map((x) => pow(x - mean, 2)).reduce((a, b) => a + b) /
+            final stddev = sqrt(timings
-                      timings.length);
+                    .map((x) => pow(x - mean, 2))
+                    .reduce((a, b) => a + b) /
+                count);
             results.add({
               'benchmark': 'Universal_$bench',
+              'phase': phase.name,
               'chainCount': c,
               'nestingDepth': d,
               'mean_us': mean.toStringAsFixed(2),
@@ -212,6 +232,7 @@ class BenchmarkCliRunner {
           }
         }
       }
+    }
     final reportGenerators = {
       'pretty': PrettyReport(),
       'csv': CsvReport(),

benchmark_di/lib/cli/parser.dart

@@ -6,12 +6,18 @@ import 'package:benchmark_di/scenarios/universal_scenario.dart';
 
 /// Enum describing all supported Universal DI benchmark types.
 enum UniversalBenchmark {
-  /// Simple singleton registration benchmark
+  /// Simple singleton registration benchmark (eager, where supported)
   registerSingleton,
 
-  /// Chain of singleton dependencies
+  /// Simple lazy singleton registration benchmark
+  registerLazySingleton,
+
+  /// Chain of eager singleton dependencies
   chainSingleton,
 
+  /// Chain of lazy singleton dependencies
+  chainLazySingleton,
+
   /// Chain using factories
   chainFactory,
 
@@ -25,12 +31,19 @@ enum UniversalBenchmark {
   override,
 }
 
+enum ResolvePhase {
+  firstResolve,
+  steadyStateResolve,
+}
+
 /// Maps [UniversalBenchmark] to the scenario enum for DI chains.
 UniversalScenario toScenario(UniversalBenchmark b) {
   switch (b) {
     case UniversalBenchmark.registerSingleton:
+    case UniversalBenchmark.registerLazySingleton:
       return UniversalScenario.register;
     case UniversalBenchmark.chainSingleton:
+    case UniversalBenchmark.chainLazySingleton:
       return UniversalScenario.chain;
     case UniversalBenchmark.chainFactory:
       return UniversalScenario.chain;
@@ -43,21 +56,21 @@ UniversalScenario toScenario(UniversalBenchmark b) {
   }
 }
 
-/// Maps benchmark to registration mode (singleton/factory/async).
+/// Maps benchmark to registration mode (singleton/lazySingleton/factory/async).
 UniversalBindingMode toMode(UniversalBenchmark b) {
   switch (b) {
     case UniversalBenchmark.registerSingleton:
-      return UniversalBindingMode.singletonStrategy;
     case UniversalBenchmark.chainSingleton:
+    case UniversalBenchmark.named:
+    case UniversalBenchmark.override:
       return UniversalBindingMode.singletonStrategy;
+    case UniversalBenchmark.registerLazySingleton:
+    case UniversalBenchmark.chainLazySingleton:
+      return UniversalBindingMode.lazySingletonStrategy;
     case UniversalBenchmark.chainFactory:
       return UniversalBindingMode.factoryStrategy;
     case UniversalBenchmark.chainAsync:
       return UniversalBindingMode.asyncStrategy;
-    case UniversalBenchmark.named:
-      return UniversalBindingMode.singletonStrategy;
-    case UniversalBenchmark.override:
-      return UniversalBindingMode.singletonStrategy;
   }
 }
 
@@ -98,6 +111,10 @@ class BenchmarkCliConfig {
 
   /// Name of DI implementation ("cherrypick" or "getit")
   final String di;
+
+  /// Which resolve phase(s) to measure.
+  final List<ResolvePhase> phases;
+
   BenchmarkCliConfig({
     required this.benchesToRun,
     required this.chainCounts,
@@ -106,6 +123,7 @@ class BenchmarkCliConfig {
     required this.warmups,
     required this.format,
     required this.di,
+    required this.phases,
   });
 }
 
@@ -119,6 +137,8 @@ BenchmarkCliConfig parseBenchmarkCli(List<String> args) {
     ..addOption('repeat', abbr: 'r', defaultsTo: '2')
     ..addOption('warmup', abbr: 'w', defaultsTo: '1')
     ..addOption('format', abbr: 'f', defaultsTo: 'pretty')
+    ..addOption('resolvePhase',
+        defaultsTo: 'all', help: 'Resolve phase: first, steady, or all')
     ..addOption('di',
         defaultsTo: 'cherrypick',
         help: 'DI implementation: cherrypick, getit or riverpod')
@@ -128,12 +148,39 @@ BenchmarkCliConfig parseBenchmarkCli(List<String> args) {
     print(parser.usage);
     exit(0);
   }
-  final benchName = result['benchmark'] as String;
+  final benchNameInput = result['benchmark'] as String;
-  final isAll = benchName == 'all';
+  final isAll = benchNameInput.trim() == 'all';
   final allBenches = UniversalBenchmark.values;
+
+  String normalizeBenchName(String name) {
+    final n = name.trim().toLowerCase();
+    return switch (n) {
+      'register' || 'registersingleton' || 'registereager' => 'registerSingleton',
+      'registerlazy' || 'registerlazysingleton' || 'registerlazysingle' => 'registerLazySingleton',
+      'chain' || 'chainsingleton' || 'chaineager' => 'chainSingleton',
+      'chainlazy' || 'chainlazysingleton' || 'lazysingleton' => 'chainLazySingleton',
+      'chainfactory' || 'factory' => 'chainFactory',
+      'async' || 'asyncchain' || 'chainasync' => 'chainAsync',
+      'named' => 'named',
+      'override' => 'override',
+      _ => n,
+    };
+  }
+
   final benchesToRun = isAll
       ? allBenches
-      : [parseEnum(benchName, allBenches, UniversalBenchmark.chainSingleton)];
+      : benchNameInput
+          .split(',')
+          .map((n) => parseEnum(normalizeBenchName(n), allBenches,
+              UniversalBenchmark.chainSingleton))
+          .toSet()
+          .toList();
+  final phaseName = (result['resolvePhase'] as String).toLowerCase();
+  final phases = switch (phaseName) {
+    'first' => [ResolvePhase.firstResolve],
+    'steady' => [ResolvePhase.steadyStateResolve],
+    _ => ResolvePhase.values,
+  };
   return BenchmarkCliConfig(
     benchesToRun: benchesToRun,
     chainCounts: parseIntList(result['chainCount'] as String),
@@ -142,5 +189,6 @@ BenchmarkCliConfig parseBenchmarkCli(List<String> args) {
     warmups: int.tryParse(result['warmup'] as String? ?? "") ?? 1,
     format: result['format'] as String,
     di: result['di'] as String? ?? 'cherrypick',
+    phases: phases,
   );
 }

benchmark_di/lib/cli/report/csv_report.dart

@@ -6,6 +6,7 @@ class CsvReport extends ReportGenerator {
   @override
   final List<String> keys = [
     'benchmark',
+    'phase',
     'chainCount',
     'nestingDepth',
     'mean_us',

benchmark_di/lib/cli/report/markdown_report.dart

@@ -8,6 +8,7 @@ class MarkdownReport extends ReportGenerator {
   @override
   final List<String> keys = [
     'benchmark',
+    'phase',
     'chainCount',
     'nestingDepth',
     'mean_us',
@@ -24,7 +25,9 @@ class MarkdownReport extends ReportGenerator {
   /// Friendly display names for each benchmark type.
   static const nameMap = {
     'Universal_UniversalBenchmark.registerSingleton': 'RegisterSingleton',
+    'Universal_UniversalBenchmark.registerLazySingleton': 'RegisterLazySingleton',
     'Universal_UniversalBenchmark.chainSingleton': 'ChainSingleton',
+    'Universal_UniversalBenchmark.chainLazySingleton': 'ChainLazySingleton',
     'Universal_UniversalBenchmark.chainFactory': 'ChainFactory',
     'Universal_UniversalBenchmark.chainAsync': 'AsyncChain',
     'Universal_UniversalBenchmark.named': 'Named',
@@ -36,6 +39,7 @@ class MarkdownReport extends ReportGenerator {
   String render(List<Map<String, dynamic>> rows) {
     final headers = [
       'Benchmark',
+      'Phase',
       'Chain Count',
       'Depth',
       'Mean (us)',
@@ -52,6 +56,7 @@ class MarkdownReport extends ReportGenerator {
       final readableName = nameMap[r['benchmark']] ?? r['benchmark'];
       return [
         readableName,
+        r['phase'],
         r['chainCount'],
         r['nestingDepth'],
         r['mean_us'],
@@ -82,6 +87,7 @@ class MarkdownReport extends ReportGenerator {
     final legend = '''
       > **Legend:**  
       > `Benchmark` – Test name  
+      > `Phase` – `firstResolve` or `steadyStateResolve`  
       > `Chain Count` – Number of independent chains  
       > `Depth` – Depth of each chain  
       > `Mean (us)` – Average time per run (microseconds)  

benchmark_di/lib/cli/report/pretty_report.dart

@@ -8,6 +8,7 @@ class PrettyReport extends ReportGenerator {
   @override
   final List<String> keys = [
     'benchmark',
+    'phase',
     'chainCount',
     'nestingDepth',
     'mean_us',
@@ -24,7 +25,9 @@ class PrettyReport extends ReportGenerator {
   /// Mappings from internal benchmark IDs to display names.
   static const nameMap = {
     'Universal_UniversalBenchmark.registerSingleton': 'RegisterSingleton',
+    'Universal_UniversalBenchmark.registerLazySingleton': 'RegisterLazySingleton',
     'Universal_UniversalBenchmark.chainSingleton': 'ChainSingleton',
+    'Universal_UniversalBenchmark.chainLazySingleton': 'ChainLazySingleton',
     'Universal_UniversalBenchmark.chainFactory': 'ChainFactory',
     'Universal_UniversalBenchmark.chainAsync': 'AsyncChain',
     'Universal_UniversalBenchmark.named': 'Named',
@@ -36,6 +39,7 @@ class PrettyReport extends ReportGenerator {
   String render(List<Map<String, dynamic>> rows) {
     final headers = [
       'Benchmark',
+      'Phase',
       'Chain Count',
       'Depth',
       'Mean (us)',
@@ -53,6 +57,7 @@ class PrettyReport extends ReportGenerator {
       final readableName = nameMap[r['benchmark']] ?? r['benchmark'];
       return [
         readableName,
+        r['phase'],
         r['chainCount'],
         r['nestingDepth'],
         r['mean_us'],

benchmark_di/lib/cli/runner.dart

@@ -2,6 +2,7 @@ import 'dart:io';
 import 'dart:math';
 import 'package:benchmark_di/benchmarks/universal_chain_benchmark.dart';
 import 'package:benchmark_di/benchmarks/universal_chain_async_benchmark.dart';
+import 'package:benchmark_di/cli/parser.dart';
 
 /// Holds the results for a single benchmark execution.
 class BenchmarkResult {
@@ -50,17 +51,24 @@ class BenchmarkRunner {
     required UniversalChainBenchmark benchmark,
     required int warmups,
     required int repeats,
+    required ResolvePhase phase,
   }) async {
     final timings = <num>[];
     final rssValues = <int>[];
     for (int i = 0; i < warmups; i++) {
       benchmark.setup();
+      if (phase == ResolvePhase.steadyStateResolve) {
+        benchmark.prewarm();
+      }
       benchmark.run();
       benchmark.teardown();
     }
     final memBefore = ProcessInfo.currentRss;
     for (int i = 0; i < repeats; i++) {
       benchmark.setup();
+      if (phase == ResolvePhase.steadyStateResolve) {
+        benchmark.prewarm();
+      }
       final sw = Stopwatch()..start();
       benchmark.run();
       sw.stop();
@@ -78,17 +86,24 @@ class BenchmarkRunner {
     required UniversalChainAsyncBenchmark benchmark,
     required int warmups,
     required int repeats,
+    required ResolvePhase phase,
   }) async {
     final timings = <num>[];
     final rssValues = <int>[];
     for (int i = 0; i < warmups; i++) {
       await benchmark.setup();
+      if (phase == ResolvePhase.steadyStateResolve) {
+        await benchmark.prewarm();
+      }
       await benchmark.run();
       await benchmark.teardown();
     }
     final memBefore = ProcessInfo.currentRss;
     for (int i = 0; i < repeats; i++) {
       await benchmark.setup();
+      if (phase == ResolvePhase.steadyStateResolve) {
+        await benchmark.prewarm();
+      }
       final sw = Stopwatch()..start();
       await benchmark.run();
       sw.stop();

benchmark_di/lib/di_adapters/cherrypick_adapter.dart

@@ -59,11 +59,16 @@ class UniversalChainModule extends Module {
 
     switch (scenario) {
       case UniversalScenario.register:
-        // Simple singleton registration.
+        if (bindingMode == UniversalBindingMode.lazySingletonStrategy) {
           bind<UniversalService>()
               .toProvide(
                   () => UniversalServiceImpl(value: 'reg', dependency: null))
               .singleton();
+        } else {
+          bind<UniversalService>()
+              .toInstance(
+                  UniversalServiceImpl(value: 'reg', dependency: null));
+        }
         break;
       case UniversalScenario.named:
         // Named factory registration for two distinct objects.
@@ -76,6 +81,8 @@ class UniversalChainModule extends Module {
         break;
       case UniversalScenario.chain:
         // Chain of nested services, with dependency on previous level by name.
+        UniversalService? lastEagerInstance;
+        final Map<String, UniversalService> eagerInstances = {};
         for (var chainIndex = 0; chainIndex < chainCount; chainIndex++) {
           for (var levelIndex = 0; levelIndex < nestingDepth; levelIndex++) {
             final chain = chainIndex + 1;
@@ -84,6 +91,17 @@ class UniversalChainModule extends Module {
             final depName = '${chain}_$level';
             switch (bindingMode) {
               case UniversalBindingMode.singletonStrategy:
+                final instance = UniversalServiceImpl(
+                  value: depName,
+                  dependency: eagerInstances[prevDepName],
+                );
+                bind<UniversalService>()
+                    .toInstance(instance)
+                    .withName(depName);
+                eagerInstances[depName] = instance;
+                lastEagerInstance = instance;
+                break;
+              case UniversalBindingMode.lazySingletonStrategy:
                 bind<UniversalService>()
                     .toProvide(() => UniversalServiceImpl(
                           value: depName,
@@ -116,15 +134,19 @@ class UniversalChainModule extends Module {
             }
           }
         }
-        // Регистрация алиаса без имени (на последний элемент цепочки)
+        // Register unnamed alias for the last chain element.
+        if (bindingMode == UniversalBindingMode.lazySingletonStrategy) {
           final depName = '${chainCount}_$nestingDepth';
           bind<UniversalService>()
               .toProvide(
                   () => currentScope.resolve<UniversalService>(named: depName))
               .singleton();
+        } else if (lastEagerInstance != null) {
+          bind<UniversalService>().toInstance(lastEagerInstance);
+        }
         break;
       case UniversalScenario.override:
-        // handled at benchmark level, но алиас нужен прямо в этом scope!
+        // Handled at benchmark level, but alias is needed directly in this scope.
         final depName = '${chainCount}_$nestingDepth';
         bind<UniversalService>()
             .toProvide(
@@ -189,7 +211,7 @@ class CherrypickDIAdapter extends DIAdapter<Scope> {
       await CherryPick.closeRootScope();
       _scope = null;
     }
-    // SubScope teardown не требуется
+    // SubScope teardown is handled by the parent scope.
   }
 
   @override

benchmark_di/lib/di_adapters/get_it_adapter.dart

@@ -4,14 +4,14 @@ import 'package:benchmark_di/scenarios/universal_service.dart';
 import 'package:get_it/get_it.dart';
 import 'di_adapter.dart';
 
-/// Универсальный DIAdapter для GetIt c поддержкой scopes и строгой типизацией.
+/// DIAdapter for GetIt with scope support and strict typing.
 class GetItAdapter extends DIAdapter<GetIt> {
   late GetIt _getIt;
   final String? _scopeName;
   final bool _isSubScope;
   bool _scopePushed = false;
 
-  /// Основной (root) и subScope-конструкторы.
+  /// Root and subScope constructors.
   GetItAdapter({GetIt? instance, String? scopeName, bool isSubScope = false})
       : _scopeName = scopeName,
         _isSubScope = isSubScope {
@@ -23,7 +23,7 @@ class GetItAdapter extends DIAdapter<GetIt> {
   @override
   void setupDependencies(void Function(GetIt container) registration) {
     if (_isSubScope) {
-      // Создаём scope через pushNewScope с init
+      // Create scope via pushNewScope with init
       _getIt.pushNewScope(
         scopeName: _scopeName,
         init: (getIt) => registration(getIt),
@@ -41,7 +41,7 @@ class GetItAdapter extends DIAdapter<GetIt> {
 
   @override
   Future<T> resolveAsync<T extends Object>({String? named}) async =>
-      _getIt<T>(instanceName: named);
+      _getIt.getAsync<T>(instanceName: named);
 
   @override
   void teardown() {
@@ -92,8 +92,13 @@ class GetItAdapter extends DIAdapter<GetIt> {
             }
             break;
           case UniversalScenario.register:
+            if (bindingMode == UniversalBindingMode.lazySingletonStrategy) {
+              getIt.registerLazySingleton<UniversalService>(
+                  () => UniversalServiceImpl(value: 'reg', dependency: null));
+            } else {
               getIt.registerSingleton<UniversalService>(
                   UniversalServiceImpl(value: 'reg', dependency: null));
+            }
             break;
           case UniversalScenario.named:
             getIt.registerFactory<UniversalService>(
@@ -120,6 +125,17 @@ class GetItAdapter extends DIAdapter<GetIt> {
                       instanceName: depName,
                     );
                     break;
+                  case UniversalBindingMode.lazySingletonStrategy:
+                    getIt.registerLazySingleton<UniversalService>(
+                      () => UniversalServiceImpl(
+                        value: depName,
+                        dependency: level > 1
+                            ? getIt<UniversalService>(instanceName: prevDepName)
+                            : null,
+                      ),
+                      instanceName: depName,
+                    );
+                    break;
                   case UniversalBindingMode.factoryStrategy:
                     getIt.registerFactory<UniversalService>(
                       () => UniversalServiceImpl(
@@ -154,10 +170,16 @@ class GetItAdapter extends DIAdapter<GetIt> {
         if (scenario == UniversalScenario.chain ||
             scenario == UniversalScenario.override) {
           final depName = '${chainCount}_$nestingDepth';
+          if (bindingMode == UniversalBindingMode.lazySingletonStrategy) {
+            getIt.registerLazySingleton<UniversalService>(
+              () => getIt<UniversalService>(instanceName: depName),
+            );
+          } else {
             getIt.registerSingleton<UniversalService>(
               getIt<UniversalService>(instanceName: depName),
             );
           }
+        }
       };
     }
     throw UnsupportedError('Scenario $scenario not supported by GetItAdapter');

benchmark_di/lib/di_adapters/kiwi_adapter.dart

@@ -4,14 +4,11 @@ import 'package:benchmark_di/scenarios/universal_service.dart';
 import 'package:kiwi/kiwi.dart';
 import 'di_adapter.dart';
 
-/// DIAdapter-для KiwiContainer с поддержкой universal benchmark сценариев.
+/// DIAdapter for KiwiContainer with universal benchmark scenario support.
 class KiwiAdapter extends DIAdapter<KiwiContainer> {
   late KiwiContainer _container;
-  // ignore: unused_field
-  final bool _isSubScope;
 
-  KiwiAdapter({KiwiContainer? container, bool isSubScope = false})
+  KiwiAdapter({KiwiContainer? container, bool isSubScope = false}) {
-      : _isSubScope = isSubScope {
     _container = container ?? KiwiContainer();
   }
 
@@ -57,6 +54,8 @@ class KiwiAdapter extends DIAdapter<KiwiContainer> {
                 final depName = '${chain}_$level';
                 switch (bindingMode) {
                   case UniversalBindingMode.singletonStrategy:
+                  case UniversalBindingMode.lazySingletonStrategy:
+                    // Kiwi's registerSingleton is lazy (factory-based, cached on first resolve)
                     container.registerSingleton<UniversalService>(
                         (c) => UniversalServiceImpl(
                             value: depName,
@@ -75,7 +74,7 @@ class KiwiAdapter extends DIAdapter<KiwiContainer> {
                         name: depName);
                     break;
                   case UniversalBindingMode.asyncStrategy:
-                    // Не поддерживается
+                    // Not supported
                     break;
                 }
               }
@@ -97,23 +96,12 @@ class KiwiAdapter extends DIAdapter<KiwiContainer> {
 
   @override
   T resolve<T extends Object>({String? named}) {
-    // Для asyncChain нужен resolve<Future<T>>
-    if (T.toString().startsWith('Future<')) {
     return _container.resolve<T>(named);
-    } else {
-      return _container.resolve<T>(named);
-    }
   }
 
   @override
-  Future<T> resolveAsync<T extends Object>({String? named}) async {
+  Future<T> resolveAsync<T extends Object>({String? named}) {
-    if (T.toString().startsWith('Future<')) {
-      // resolve<Future<T>>, unwrap result
     return Future.value(_container.resolve<T>(named));
-    } else {
-      // Для совместимости с chain/override
-      return Future.value(_container.resolve<T>(named));
-    }
   }
 
   @override
@@ -123,7 +111,7 @@ class KiwiAdapter extends DIAdapter<KiwiContainer> {
 
   @override
   KiwiAdapter openSubScope(String name) {
-    // Возвращаем новый scoped контейнер (отдельный). Наследование не реализовано.
+    // Returns a new scoped container. Inheritance not implemented.
     return KiwiAdapter(container: KiwiContainer.scoped(), isSubScope: true);
   }
 

benchmark_di/lib/di_adapters/yx_scope_adapter.dart

@@ -29,8 +29,7 @@ class YxScopeAdapter extends DIAdapter<UniversalYxScopeContainer> {
 
   @override
   void teardown() {
-    // У yx_scope нет явного dispose на ScopeContainer, но можно добавить очистку Map/Deps если потребуется
+    _scope = UniversalYxScopeContainer();
-    // Ничего не делаем
   }
 
   @override
@@ -54,26 +53,13 @@ class YxScopeAdapter extends DIAdapter<UniversalYxScopeContainer> {
     required UniversalBindingMode bindingMode,
   }) {
     if (scenario is UniversalScenario) {
+      if (scenario == UniversalScenario.asyncChain ||
+          bindingMode == UniversalBindingMode.asyncStrategy) {
+        throw UnsupportedError(
+            'YxScope does not support async dependencies or async binding scenarios.');
+      }
       return (scope) {
         switch (scenario) {
-          case UniversalScenario.asyncChain:
-            for (int chain = 1; chain <= chainCount; chain++) {
-              for (int level = 1; level <= nestingDepth; level++) {
-                final prevDepName = '${chain}_${level - 1}';
-                final depName = '${chain}_$level';
-                final dep = scope.dep<UniversalService>(
-                  () => UniversalServiceImpl(
-                    value: depName,
-                    dependency: level > 1
-                        ? scope.depFor<UniversalService>(name: prevDepName).get
-                        : null,
-                  ),
-                  name: depName,
-                );
-                scope.register<UniversalService>(dep, name: depName);
-              }
-            }
-            break;
           case UniversalScenario.register:
             final dep = scope.dep<UniversalService>(
               () => UniversalServiceImpl(value: 'reg', dependency: null),
@@ -113,6 +99,8 @@ class YxScopeAdapter extends DIAdapter<UniversalYxScopeContainer> {
           case UniversalScenario.override:
             // handled at benchmark level
             break;
+          default:
+            break;
         }
         if (scenario == UniversalScenario.chain ||
             scenario == UniversalScenario.override) {

benchmark_di/lib/scenarios/universal_binding_mode.dart

@@ -1,9 +1,12 @@
 /// Enum to represent the DI registration/binding mode.
 enum UniversalBindingMode {
-  /// Singleton/provider binding.
+  /// Eager singleton — instance created at registration time.
   singletonStrategy,
 
-  /// Factory-based binding.
+  /// Lazy singleton — instance created on first resolve, then cached.
+  lazySingletonStrategy,
+
+  /// Factory-based binding — new instance every time.
   factoryStrategy,
 
   /// Async-based binding.