chore(release): publish packages

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

.gitignore

@@ -17,4 +17,6 @@ pubspec_overrides.yaml
 
 melos_cherrypick.iml
 melos_cherrypick_workspace.iml
-melos_cherrypick_flutter.iml
+melos_cherrypick_flutter.iml
+
+coverage

CHANGELOG.md

@@ -3,6 +3,59 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2025-07-30
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`cherrypick` - `v3.0.0-dev.1`](#cherrypick---v300-dev1)
+ - [`cherrypick_flutter` - `v1.1.3-dev.1`](#cherrypick_flutter---v113-dev1)
+
+Packages with dependency updates only:
+
+> Packages listed below depend on other packages in this workspace that have had changes. Their versions have been incremented to bump the minimum dependency versions of the packages they depend upon in this project.
+
+ - `cherrypick_flutter` - `v1.1.3-dev.1`
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.1`
+
+ - **DOCS**: add quick guide for circular dependency detection to README.
+
+
+## 2025-07-30
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - [`cherrypick` - `v3.0.0-dev.0`](#cherrypick---v300-dev0)
+
+Packages with other changes:
+
+ - [`cherrypick_flutter` - `v1.1.3-dev.0`](#cherrypick_flutter---v113-dev0)
+
+---
+
+#### `cherrypick` - `v3.0.0-dev.0`
+
+ - **BREAKING** **FEAT**: implement comprehensive circular dependency detection system.
+
+#### `cherrypick_flutter` - `v1.1.3-dev.0`
+
+ - **FIX**: update deps.
+
+
 ## 2025-07-28
 
 ### Changes

cherrypick/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 3.0.0-dev.1
+
+ - **DOCS**: add quick guide for circular dependency detection to README.
+
+## 3.0.0-dev.0
+
+> Note: This release has breaking changes.
+
+ - **BREAKING** **FEAT**: implement comprehensive circular dependency detection system.
+
 ## 2.2.0
 
  - Graduate package to a stable release. See pre-releases prior to this version for changelog entries.

cherrypick/README.md

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

cherrypick/example/cherrypick_helper_example.dart

@@ -0,0 +1,230 @@
+import 'package:cherrypick/cherrypick.dart';
+
+// Пример сервисов для демонстрации
+class DatabaseService {
+  void connect() => print('🔌 Connecting to database');
+}
+
+class ApiService {
+  final DatabaseService database;
+  ApiService(this.database);
+  
+  void fetchData() {
+    database.connect();
+    print('📡 Fetching data via API');
+  }
+}
+
+class UserService {
+  final ApiService apiService;
+  UserService(this.apiService);
+  
+  void getUser(String id) {
+    apiService.fetchData();
+    print('👤 Fetching user: $id');
+  }
+}
+
+// Модули для различных feature
+class DatabaseModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<DatabaseService>().singleton().toProvide(() => DatabaseService());
+  }
+}
+
+class ApiModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<ApiService>().toProvide(() => ApiService(
+      currentScope.resolve<DatabaseService>()
+    ));
+  }
+}
+
+class UserModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<UserService>().toProvide(() => UserService(
+      currentScope.resolve<ApiService>()
+    ));
+  }
+}
+
+// Пример циклических зависимостей для демонстрации обнаружения
+class CircularServiceA {
+  final CircularServiceB serviceB;
+  CircularServiceA(this.serviceB);
+}
+
+class CircularServiceB {
+  final CircularServiceA serviceA;
+  CircularServiceB(this.serviceA);
+}
+
+class CircularModuleA extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<CircularServiceA>().toProvide(() => CircularServiceA(
+      currentScope.resolve<CircularServiceB>()
+    ));
+  }
+}
+
+class CircularModuleB extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<CircularServiceB>().toProvide(() => CircularServiceB(
+      currentScope.resolve<CircularServiceA>()
+    ));
+  }
+}
+
+void main() {
+  print('=== Improved CherryPick Helper Demonstration ===\n');
+  
+  // Example 1: Global enabling of cycle detection
+  print('1. Globally enable cycle detection:');
+  
+  CherryPick.enableGlobalCycleDetection();
+  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}');
+  
+  // Install modules without circular dependencies
+  globalScope.installModules([
+    DatabaseModule(),
+    ApiModule(),
+    UserModule(),
+  ]);
+  
+  final userService = globalScope.resolve<UserService>();
+  userService.getUser('user123');
+  print('');
+  
+  // Example 2: Safe scope creation
+  print('2. Creating safe scopes:');
+  
+  CherryPick.closeRootScope(); // Закрываем предыдущий скоуп
+  CherryPick.disableGlobalCycleDetection(); // Отключаем глобальную настройку
+  
+  // Создаем безопасный скоуп (с автоматически включенным обнаружением)
+  final safeScope = CherryPick.openSafeRootScope();
+  print('✅ Safe scope created with cycle detection: ${safeScope.isCycleDetectionEnabled}');
+  
+  safeScope.installModules([
+    DatabaseModule(),
+    ApiModule(),
+    UserModule(),
+  ]);
+  
+  final safeUserService = safeScope.resolve<UserService>();
+  safeUserService.getUser('safe_user456');
+  print('');
+  
+  // Example 3: Detecting cycles
+  print('3. Detecting circular dependencies:');
+  
+  final cyclicScope = CherryPick.openSafeRootScope();
+  cyclicScope.installModules([
+    CircularModuleA(),
+    CircularModuleB(),
+  ]);
+  
+  try {
+    cyclicScope.resolve<CircularServiceA>();
+    print('❌ This should not be executed');
+  } catch (e) {
+    if (e is CircularDependencyException) {
+      print('❌ Circular dependency detected!');
+      print('   Message: ${e.message}');
+      print('   Chain: ${e.dependencyChain.join(' -> ')}');
+    }
+  }
+  print('');
+  
+  // Example 4: Managing detection for specific scopes
+  print('4. Managing detection for specific scopes:');
+  
+  CherryPick.closeRootScope();
+  
+  // Создаем скоуп без обнаружения
+  // ignore: unused_local_variable
+  final specificScope = CherryPick.openRootScope();
+  print('   Detection in root scope: ${CherryPick.isCycleDetectionEnabledForScope()}');
+  
+  // Включаем обнаружение для конкретного скоупа
+  CherryPick.enableCycleDetectionForScope();
+  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')}');
+  
+  // Включаем обнаружение для дочернего скоупа
+  CherryPick.enableCycleDetectionForScope(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');
+  print('✅ Safe feature scope created: ${safeFeatureScope.isCycleDetectionEnabled}');
+  
+  // You can create a complex hierarchy of scopes
+  final complexScope = CherryPick.openSafeScope(scopeName: 'app.feature.auth.login');
+  print('✅ Complex scope created: ${complexScope.isCycleDetectionEnabled}');
+  print('');
+  
+  // Example 6: Tracking resolution chains
+  print('6. Tracking dependency resolution chains:');
+  
+  final trackingScope = CherryPick.openSafeRootScope();
+  trackingScope.installModules([
+    DatabaseModule(),
+    ApiModule(),
+    UserModule(),
+  ]);
+  
+  print('   Chain before resolve: ${CherryPick.getCurrentResolutionChain()}');
+  
+  // The chain is populated during resolution, but cleared after completion
+  // ignore: unused_local_variable
+  final trackedUserService = trackingScope.resolve<UserService>();
+  print('   Chain after resolve: ${CherryPick.getCurrentResolutionChain()}');
+  print('');
+  
+  // Example 7: Usage recommendations
+  print('7. Recommended usage:');
+  print('');
+  
+  print('🔧 Development mode:');
+  print('   CherryPick.enableGlobalCycleDetection(); // Enable globally');
+  print('   or');
+  print('   final scope = CherryPick.openSafeRootScope(); // Safe scope');
+  print('');
+  
+  print('🚀 Production mode:');
+  print('   CherryPick.disableGlobalCycleDetection(); // Disable for performance');
+  print('   final scope = CherryPick.openRootScope(); // Regular scope');
+  print('');
+  
+  print('🧪 Testing:');
+  print('   setUp(() => CherryPick.enableGlobalCycleDetection());');
+  print('   tearDown(() => CherryPick.closeRootScope());');
+  print('');
+  
+  print('🎯 Feature-specific:');
+  print('   CherryPick.enableCycleDetectionForScope(scopeName: "feature.critical");');
+  print('   // Enable only for critical features');
+  
+  // Cleanup
+  CherryPick.closeRootScope();
+  CherryPick.disableGlobalCycleDetection();
+  
+  print('\n=== Demonstration complete ===');
+}

cherrypick/example/cycle_detection_example.dart

@@ -0,0 +1,197 @@
+import 'package:cherrypick/cherrypick.dart';
+
+// Пример сервисов с циклической зависимостью
+class UserService {
+  final OrderService orderService;
+  
+  UserService(this.orderService);
+  
+  void createUser(String name) {
+    print('Creating user: $name');
+    // Пытаемся получить заказы пользователя, что создает циклическую зависимость
+    orderService.getOrdersForUser(name);
+  }
+}
+
+class OrderService {
+  final UserService userService;
+  
+  OrderService(this.userService);
+  
+  void getOrdersForUser(String userName) {
+    print('Getting orders for user: $userName');
+    // Пытаемся получить информацию о пользователе, что создает циклическую зависимость
+    userService.createUser(userName);
+  }
+}
+
+// Модули с циклическими зависимостями
+class UserModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<UserService>().toProvide(() => UserService(
+      currentScope.resolve<OrderService>()
+    ));
+  }
+}
+
+class OrderModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<OrderService>().toProvide(() => OrderService(
+      currentScope.resolve<UserService>()
+    ));
+  }
+}
+
+// Правильная реализация без циклических зависимостей
+class UserRepository {
+  void createUser(String name) {
+    print('Creating user in repository: $name');
+  }
+  
+  String getUserInfo(String name) {
+    return 'User info for: $name';
+  }
+}
+
+class OrderRepository {
+  void createOrder(String orderId, String userName) {
+    print('Creating order $orderId for user: $userName');
+  }
+  
+  List<String> getOrdersForUser(String userName) {
+    return ['order1', 'order2', 'order3'];
+  }
+}
+
+class ImprovedUserService {
+  final UserRepository userRepository;
+  
+  ImprovedUserService(this.userRepository);
+  
+  void createUser(String name) {
+    userRepository.createUser(name);
+  }
+  
+  String getUserInfo(String name) {
+    return userRepository.getUserInfo(name);
+  }
+}
+
+class ImprovedOrderService {
+  final OrderRepository orderRepository;
+  final ImprovedUserService userService;
+  
+  ImprovedOrderService(this.orderRepository, this.userService);
+  
+  void createOrder(String orderId, String userName) {
+    // Проверяем, что пользователь существует
+    final userInfo = userService.getUserInfo(userName);
+    print('User exists: $userInfo');
+    
+    orderRepository.createOrder(orderId, userName);
+  }
+  
+  List<String> getOrdersForUser(String userName) {
+    return orderRepository.getOrdersForUser(userName);
+  }
+}
+
+// Правильные модули без циклических зависимостей
+class ImprovedUserModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<UserRepository>().singleton().toProvide(() => UserRepository());
+    bind<ImprovedUserService>().toProvide(() => ImprovedUserService(
+      currentScope.resolve<UserRepository>()
+    ));
+  }
+}
+
+class ImprovedOrderModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<OrderRepository>().singleton().toProvide(() => OrderRepository());
+    bind<ImprovedOrderService>().toProvide(() => ImprovedOrderService(
+      currentScope.resolve<OrderRepository>(),
+      currentScope.resolve<ImprovedUserService>()
+    ));
+  }
+}
+
+void main() {
+  print('=== Circular Dependency Detection Example ===\n');
+  
+  // Example 1: Demonstrate circular dependency
+  print('1. Attempt to create a scope with circular dependencies:');
+  try {
+    final scope = Scope(null);
+    scope.enableCycleDetection(); // Включаем обнаружение циклических зависимостей
+    
+    scope.installModules([
+      UserModule(),
+      OrderModule(),
+    ]);
+    
+    // Это должно выбросить CircularDependencyException
+    final userService = scope.resolve<UserService>();
+    print('UserService created: $userService');
+  } catch (e) {
+    print('❌ Circular dependency detected: $e\n');
+  }
+  
+  // Example 2: Without circular dependency detection (dangerous!)
+  print('2. Same code without circular dependency detection:');
+  try {
+    final scope = Scope(null);
+    // НЕ включаем обнаружение циклических зависимостей
+    
+    scope.installModules([
+      UserModule(),
+      OrderModule(),
+    ]);
+    
+    // Это приведет к StackOverflowError при попытке использования
+    final userService = scope.resolve<UserService>();
+    print('UserService создан: $userService');
+    
+    // Попытка использовать сервис приведет к бесконечной рекурсии
+    // userService.createUser('John'); // Раскомментируйте для демонстрации StackOverflow
+    print('⚠️  UserService created, but using it will cause StackOverflow\n');
+  } catch (e) {
+    print('❌ Error: $e\n');
+  }
+  
+  // Example 3: Correct architecture without circular dependencies
+  print('3. Correct architecture without circular dependencies:');
+  try {
+    final scope = Scope(null);
+    scope.enableCycleDetection(); // Включаем для безопасности
+    
+    scope.installModules([
+      ImprovedUserModule(),
+      ImprovedOrderModule(),
+    ]);
+    
+    final userService = scope.resolve<ImprovedUserService>();
+    final orderService = scope.resolve<ImprovedOrderService>();
+    
+    print('✅ Services created successfully');
+    
+    // Демонстрация работы
+    userService.createUser('John');
+    orderService.createOrder('ORD-001', 'John');
+    final orders = orderService.getOrdersForUser('John');
+    print('✅ Orders for user John: $orders');
+    
+  } catch (e) {
+    print('❌ Error: $e');
+  }
+  
+  print('\n=== Recommendations ===');
+  print('1. Always enable circular dependency detection in development mode.');
+  print('2. Use repositories and services to separate concerns.');
+  print('3. Avoid mutual dependencies between services at the same level.');
+  print('4. Use events or mediators to decouple components.');
+}

cherrypick/lib/cherrypick.dart

@@ -14,6 +14,8 @@ library;
 //
 
 export 'package:cherrypick/src/binding.dart';
+export 'package:cherrypick/src/cycle_detector.dart';
+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';

cherrypick/lib/src/cycle_detector.dart

@@ -0,0 +1,167 @@
+//
+// 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
+//      http://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 'dart:collection';
+
+/// RU: Исключение, выбрасываемое при обнаружении циклической зависимости.
+/// ENG: Exception thrown when a circular dependency is detected.
+class CircularDependencyException implements Exception {
+  final String message;
+  final List<String> dependencyChain;
+
+  const CircularDependencyException(this.message, this.dependencyChain);
+
+  @override
+  String toString() {
+    final chain = dependencyChain.join(' -> ');
+    return 'CircularDependencyException: $message\nDependency chain: $chain';
+  }
+}
+
+/// RU: Детектор циклических зависимостей для CherryPick DI контейнера.
+/// ENG: Circular dependency detector for CherryPick DI container.
+class CycleDetector {
+  // Стек текущих разрешаемых зависимостей
+  final Set<String> _resolutionStack = HashSet<String>();
+  
+  // История разрешения для построения цепочки зависимостей
+  final List<String> _resolutionHistory = [];
+
+  /// RU: Начинает отслеживание разрешения зависимости.
+  /// ENG: Starts tracking dependency resolution.
+  /// 
+  /// Throws [CircularDependencyException] if circular dependency is detected.
+  void startResolving<T>({String? named}) {
+    final dependencyKey = _createDependencyKey<T>(named);
+    
+    if (_resolutionStack.contains(dependencyKey)) {
+      // Найдена циклическая зависимость
+      final cycleStartIndex = _resolutionHistory.indexOf(dependencyKey);
+      final cycle = _resolutionHistory.sublist(cycleStartIndex)..add(dependencyKey);
+      
+      throw CircularDependencyException(
+        'Circular dependency detected for $dependencyKey',
+        cycle,
+      );
+    }
+    
+    _resolutionStack.add(dependencyKey);
+    _resolutionHistory.add(dependencyKey);
+  }
+
+  /// RU: Завершает отслеживание разрешения зависимости.
+  /// ENG: Finishes tracking dependency resolution.
+  void finishResolving<T>({String? named}) {
+    final dependencyKey = _createDependencyKey<T>(named);
+    _resolutionStack.remove(dependencyKey);
+    
+    // Удаляем из истории только если это последний элемент
+    if (_resolutionHistory.isNotEmpty && 
+        _resolutionHistory.last == dependencyKey) {
+      _resolutionHistory.removeLast();
+    }
+  }
+
+  /// RU: Очищает все состояние детектора.
+  /// ENG: Clears all detector state.
+  void clear() {
+    _resolutionStack.clear();
+    _resolutionHistory.clear();
+  }
+
+  /// RU: Проверяет, находится ли зависимость в процессе разрешения.
+  /// ENG: Checks if dependency is currently being resolved.
+  bool isResolving<T>({String? named}) {
+    final dependencyKey = _createDependencyKey<T>(named);
+    return _resolutionStack.contains(dependencyKey);
+  }
+
+  /// RU: Возвращает текущую цепочку разрешения зависимостей.
+  /// ENG: Returns current dependency resolution chain.
+  List<String> get currentResolutionChain => List.unmodifiable(_resolutionHistory);
+
+  /// RU: Создает уникальный ключ для зависимости.
+  /// ENG: Creates unique key for dependency.
+  String _createDependencyKey<T>(String? named) {
+    final typeName = T.toString();
+    return named != null ? '$typeName@$named' : typeName;
+  }
+}
+
+/// RU: Миксин для добавления поддержки обнаружения циклических зависимостей.
+/// ENG: Mixin for adding circular dependency detection support.
+mixin CycleDetectionMixin {
+  CycleDetector? _cycleDetector;
+
+  /// RU: Включает обнаружение циклических зависимостей.
+  /// ENG: Enables circular dependency detection.
+  void enableCycleDetection() {
+    _cycleDetector = CycleDetector();
+  }
+
+  /// RU: Отключает обнаружение циклических зависимостей.
+  /// ENG: Disables circular dependency detection.
+  void disableCycleDetection() {
+    _cycleDetector?.clear();
+    _cycleDetector = null;
+  }
+
+  /// RU: Проверяет, включено ли обнаружение циклических зависимостей.
+  /// ENG: Checks if circular dependency detection is enabled.
+  bool get isCycleDetectionEnabled => _cycleDetector != null;
+
+  /// RU: Выполняет действие с отслеживанием циклических зависимостей.
+  /// ENG: Executes action with circular dependency tracking.
+  T withCycleDetection<T>(
+    Type dependencyType,
+    String? named,
+    T Function() action,
+  ) {
+    if (_cycleDetector == null) {
+      return action();
+    }
+
+    final dependencyKey = named != null 
+        ? '${dependencyType.toString()}@$named' 
+        : dependencyType.toString();
+
+    if (_cycleDetector!._resolutionStack.contains(dependencyKey)) {
+      final cycleStartIndex = _cycleDetector!._resolutionHistory.indexOf(dependencyKey);
+      final cycle = _cycleDetector!._resolutionHistory.sublist(cycleStartIndex)
+        ..add(dependencyKey);
+      
+      throw CircularDependencyException(
+        'Circular dependency detected for $dependencyKey',
+        cycle,
+      );
+    }
+
+    _cycleDetector!._resolutionStack.add(dependencyKey);
+    _cycleDetector!._resolutionHistory.add(dependencyKey);
+
+    try {
+      return action();
+    } finally {
+      _cycleDetector!._resolutionStack.remove(dependencyKey);
+      if (_cycleDetector!._resolutionHistory.isNotEmpty && 
+          _cycleDetector!._resolutionHistory.last == dependencyKey) {
+        _cycleDetector!._resolutionHistory.removeLast();
+      }
+    }
+  }
+
+  /// RU: Возвращает текущую цепочку разрешения зависимостей.
+  /// ENG: Returns current dependency resolution chain.
+  List<String> get currentResolutionChain => 
+      _cycleDetector?.currentResolutionChain ?? [];
+}

cherrypick/lib/src/global_cycle_detector.dart

@@ -0,0 +1,222 @@
+//
+// 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
+//      http://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 'dart:collection';
+import 'package:cherrypick/src/cycle_detector.dart';
+
+/// RU: Глобальный детектор циклических зависимостей для всей иерархии скоупов.
+/// ENG: Global circular dependency detector for entire scope hierarchy.
+class GlobalCycleDetector {
+  static GlobalCycleDetector? _instance;
+  
+  // Глобальный стек разрешения зависимостей
+  final Set<String> _globalResolutionStack = HashSet<String>();
+  
+  // История разрешения для построения цепочки зависимостей
+  final List<String> _globalResolutionHistory = [];
+  
+  // Карта активных детекторов по скоупам
+  final Map<String, CycleDetector> _scopeDetectors = HashMap<String, CycleDetector>();
+
+  GlobalCycleDetector._internal();
+
+  /// RU: Получить единственный экземпляр глобального детектора.
+  /// ENG: Get singleton instance of global detector.
+  static GlobalCycleDetector get instance {
+    _instance ??= GlobalCycleDetector._internal();
+    return _instance!;
+  }
+
+  /// RU: Сбросить глобальный детектор (полезно для тестов).
+  /// ENG: Reset global detector (useful for tests).
+  static void reset() {
+    _instance?._globalResolutionStack.clear();
+    _instance?._globalResolutionHistory.clear();
+    _instance?._scopeDetectors.clear();
+    _instance = null;
+  }
+
+  /// RU: Начать отслеживание разрешения зависимости в глобальном контексте.
+  /// ENG: Start tracking dependency resolution in global context.
+  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);
+      
+      throw CircularDependencyException(
+        'Global circular dependency detected for $dependencyKey',
+        cycle,
+      );
+    }
+    
+    _globalResolutionStack.add(dependencyKey);
+    _globalResolutionHistory.add(dependencyKey);
+  }
+
+  /// RU: Завершить отслеживание разрешения зависимости в глобальном контексте.
+  /// 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: Выполнить действие с глобальным отслеживанием циклических зависимостей.
+  /// ENG: Execute action with global circular dependency tracking.
+  T withGlobalCycleDetection<T>(
+    Type dependencyType,
+    String? named,
+    String? scopeId,
+    T Function() action,
+  ) {
+    final dependencyKey = _createDependencyKeyFromType(dependencyType, named, scopeId);
+    
+    if (_globalResolutionStack.contains(dependencyKey)) {
+      final cycleStartIndex = _globalResolutionHistory.indexOf(dependencyKey);
+      final cycle = _globalResolutionHistory.sublist(cycleStartIndex)
+        ..add(dependencyKey);
+      
+      throw CircularDependencyException(
+        'Global circular dependency detected for $dependencyKey',
+        cycle,
+      );
+    }
+
+    _globalResolutionStack.add(dependencyKey);
+    _globalResolutionHistory.add(dependencyKey);
+
+    try {
+      return action();
+    } finally {
+      _globalResolutionStack.remove(dependencyKey);
+      if (_globalResolutionHistory.isNotEmpty && 
+          _globalResolutionHistory.last == dependencyKey) {
+        _globalResolutionHistory.removeLast();
+      }
+    }
+  }
+
+  /// RU: Получить детектор для конкретного скоупа.
+  /// ENG: Get detector for specific scope.
+  CycleDetector getScopeDetector(String scopeId) {
+    return _scopeDetectors.putIfAbsent(scopeId, () => CycleDetector());
+  }
+
+  /// RU: Удалить детектор для скоупа.
+  /// ENG: Remove detector for scope.
+  void removeScopeDetector(String scopeId) {
+    _scopeDetectors.remove(scopeId);
+  }
+
+  /// RU: Проверить, находится ли зависимость в процессе глобального разрешения.
+  /// 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: Получить текущую глобальную цепочку разрешения зависимостей.
+  /// ENG: Get current global dependency resolution chain.
+  List<String> get globalResolutionChain => List.unmodifiable(_globalResolutionHistory);
+
+  /// RU: Очистить все состояние детектора.
+  /// ENG: Clear all detector state.
+  void clear() {
+    _globalResolutionStack.clear();
+    _globalResolutionHistory.clear();
+    _scopeDetectors.values.forEach(_detectorClear);
+    _scopeDetectors.clear();
+  }
+
+  void _detectorClear(detector) => detector.clear();
+
+  /// RU: Создать уникальный ключ для зависимости с учетом скоупа.
+  /// ENG: Create unique key for dependency including scope.
+  //String _createDependencyKey<T>(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]' : '';
+    return '$scopePrefix$typeName$namePrefix';
+  }
+}
+
+/// RU: Улучшенный миксин для глобального обнаружения циклических зависимостей.
+/// ENG: Enhanced mixin for global circular dependency detection.
+mixin GlobalCycleDetectionMixin {
+  String? _scopeId;
+  bool _globalCycleDetectionEnabled = false;
+
+  /// RU: Установить идентификатор скоупа для глобального отслеживания.
+  /// ENG: Set scope identifier for global tracking.
+  void setScopeId(String scopeId) {
+    _scopeId = scopeId;
+  }
+
+  /// RU: Получить идентификатор скоупа.
+  /// ENG: Get scope identifier.
+  String? get scopeId => _scopeId;
+
+  /// RU: Включить глобальное обнаружение циклических зависимостей.
+  /// ENG: Enable global circular dependency detection.
+  void enableGlobalCycleDetection() {
+    _globalCycleDetectionEnabled = true;
+  }
+
+  /// RU: Отключить глобальное обнаружение циклических зависимостей.
+  /// ENG: Disable global circular dependency detection.
+  void disableGlobalCycleDetection() {
+    _globalCycleDetectionEnabled = false;
+  }
+
+  /// RU: Проверить, включено ли глобальное обнаружение циклических зависимостей.
+  /// ENG: Check if global circular dependency detection is enabled.
+  bool get isGlobalCycleDetectionEnabled => _globalCycleDetectionEnabled;
+
+  /// RU: Выполнить действие с глобальным отслеживанием циклических зависимостей.
+  /// ENG: Execute action with global circular dependency tracking.
+  T withGlobalCycleDetection<T>(
+    Type dependencyType,
+    String? named,
+    T Function() action,
+  ) {
+    if (!_globalCycleDetectionEnabled) {
+      return action();
+    }
+
+    return GlobalCycleDetector.instance.withGlobalCycleDetection<T>(
+      dependencyType,
+      named,
+      _scopeId,
+      action,
+    );
+  }
+
+  /// RU: Получить текущую глобальную цепочку разрешения зависимостей.
+  /// ENG: Get current global dependency resolution chain.
+  List<String> get globalResolutionChain => 
+      GlobalCycleDetector.instance.globalResolutionChain;
+}

cherrypick/lib/src/helper.dart

@@ -11,9 +11,12 @@
 // limitations under the License.
 //
 import 'package:cherrypick/src/scope.dart';
+import 'package:cherrypick/src/global_cycle_detector.dart';
 import 'package:meta/meta.dart';
 
 Scope? _rootScope;
+bool _globalCycleDetectionEnabled = false;
+bool _globalCrossScopeCycleDetectionEnabled = false;
 
 class CherryPick {
   /// RU: Метод открывает главный [Scope].
@@ -22,6 +25,17 @@ class CherryPick {
   /// return
   static Scope openRootScope() {
     _rootScope ??= Scope(null);
+    
+    // Применяем глобальную настройку обнаружения циклических зависимостей
+    if (_globalCycleDetectionEnabled && !_rootScope!.isCycleDetectionEnabled) {
+      _rootScope!.enableCycleDetection();
+    }
+    
+    // Применяем глобальную настройку обнаружения между скоупами
+    if (_globalCrossScopeCycleDetectionEnabled && !_rootScope!.isGlobalCycleDetectionEnabled) {
+      _rootScope!.enableGlobalCycleDetection();
+    }
+    
     return _rootScope!;
   }
 
@@ -35,6 +49,150 @@ class CherryPick {
     }
   }
 
+  /// RU: Глобально включает обнаружение циклических зависимостей для всех новых скоупов.
+  /// ENG: Globally enables circular dependency detection for all new scopes.
+  ///
+  /// Этот метод влияет на все скоупы, создаваемые через CherryPick.
+  /// This method affects all scopes created through CherryPick.
+  ///
+  /// Example:
+  /// ```dart
+  /// CherryPick.enableGlobalCycleDetection();
+  /// final scope = CherryPick.openRootScope(); // Автоматически включено обнаружение
+  /// ```
+  static void enableGlobalCycleDetection() {
+    _globalCycleDetectionEnabled = true;
+    
+    // Включаем для уже существующего root scope, если он есть
+    if (_rootScope != null) {
+      _rootScope!.enableCycleDetection();
+    }
+  }
+
+  /// RU: Глобально отключает обнаружение циклических зависимостей.
+  /// ENG: Globally disables circular dependency detection.
+  ///
+  /// Рекомендуется использовать в production для максимальной производительности.
+  /// Recommended for production use for maximum performance.
+  ///
+  /// Example:
+  /// ```dart
+  /// CherryPick.disableGlobalCycleDetection();
+  /// ```
+  static void disableGlobalCycleDetection() {
+    _globalCycleDetectionEnabled = false;
+    
+    // Отключаем для уже существующего root scope, если он есть
+    if (_rootScope != null) {
+      _rootScope!.disableCycleDetection();
+    }
+  }
+
+  /// RU: Проверяет, включено ли глобальное обнаружение циклических зависимостей.
+  /// ENG: Checks if global circular dependency detection is enabled.
+  ///
+  /// return true если включено, false если отключено
+  /// return true if enabled, false if disabled
+  static bool get isGlobalCycleDetectionEnabled => _globalCycleDetectionEnabled;
+
+  /// RU: Включает обнаружение циклических зависимостей для конкретного скоупа.
+  /// ENG: Enables circular dependency detection for a specific scope.
+  ///
+  /// [scopeName] - имя скоупа (пустая строка для root scope)
+  /// [scopeName] - scope name (empty string for root scope)
+  ///
+  /// Example:
+  /// ```dart
+  /// CherryPick.enableCycleDetectionForScope(); // Для root scope
+  /// CherryPick.enableCycleDetectionForScope(scopeName: 'feature.auth'); // Для конкретного scope
+  /// ```
+  static void enableCycleDetectionForScope({String scopeName = '', String separator = '.'}) {
+    final scope = _getScope(scopeName, separator);
+    scope.enableCycleDetection();
+  }
+
+  /// RU: Отключает обнаружение циклических зависимостей для конкретного скоупа.
+  /// ENG: Disables circular dependency detection for a specific scope.
+  ///
+  /// [scopeName] - имя скоупа (пустая строка для root scope)
+  /// [scopeName] - scope name (empty string for root scope)
+  static void disableCycleDetectionForScope({String scopeName = '', String separator = '.'}) {
+    final scope = _getScope(scopeName, separator);
+    scope.disableCycleDetection();
+  }
+
+  /// RU: Проверяет, включено ли обнаружение циклических зависимостей для конкретного скоупа.
+  /// ENG: Checks if circular dependency detection is enabled for a specific scope.
+  ///
+  /// [scopeName] - имя скоупа (пустая строка для root scope)
+  /// [scopeName] - scope name (empty string for root scope)
+  ///
+  /// return true если включено, false если отключено
+  /// return true if enabled, false if disabled
+  static bool isCycleDetectionEnabledForScope({String scopeName = '', String separator = '.'}) {
+    final scope = _getScope(scopeName, separator);
+    return scope.isCycleDetectionEnabled;
+  }
+
+  /// RU: Возвращает текущую цепочку разрешения зависимостей для конкретного скоупа.
+  /// ENG: Returns current dependency resolution chain for a specific scope.
+  ///
+  /// Полезно для отладки и анализа зависимостей.
+  /// Useful for debugging and dependency analysis.
+  ///
+  /// [scopeName] - имя скоупа (пустая строка для root scope)
+  /// [scopeName] - scope name (empty string for root scope)
+  ///
+  /// return список имен зависимостей в текущей цепочке разрешения
+  /// return list of dependency names in current resolution chain
+  static List<String> getCurrentResolutionChain({String scopeName = '', String separator = '.'}) {
+    final scope = _getScope(scopeName, separator);
+    return scope.currentResolutionChain;
+  }
+
+  /// RU: Создает новый скоуп с автоматически включенным обнаружением циклических зависимостей.
+  /// ENG: Creates a new scope with automatically enabled circular dependency detection.
+  ///
+  /// Удобный метод для создания безопасных скоупов в development режиме.
+  /// Convenient method for creating safe scopes in development mode.
+  ///
+  /// Example:
+  /// ```dart
+  /// final scope = CherryPick.openSafeRootScope();
+  /// // Обнаружение циклических зависимостей автоматически включено
+  /// ```
+  static Scope openSafeRootScope() {
+    final scope = openRootScope();
+    scope.enableCycleDetection();
+    return scope;
+  }
+
+  /// RU: Создает новый дочерний скоуп с автоматически включенным обнаружением циклических зависимостей.
+  /// ENG: Creates a new child scope with automatically enabled circular dependency detection.
+  ///
+  /// [scopeName] - имя скоупа
+  /// [scopeName] - scope name
+  ///
+  /// Example:
+  /// ```dart
+  /// final scope = CherryPick.openSafeScope(scopeName: 'feature.auth');
+  /// // Обнаружение циклических зависимостей автоматически включено
+  /// ```
+  static Scope openSafeScope({String scopeName = '', String separator = '.'}) {
+    final scope = openScope(scopeName: scopeName, separator: separator);
+    scope.enableCycleDetection();
+    return scope;
+  }
+
+  /// RU: Внутренний метод для получения скоупа по имени.
+  /// ENG: Internal method to get scope by name.
+  static Scope _getScope(String scopeName, String separator) {
+    if (scopeName.isEmpty) {
+      return openRootScope();
+    }
+    return openScope(scopeName: scopeName, separator: separator);
+  }
+
   /// RU: Метод открывает  дочерний [Scope].
   /// ENG: The method open the child [Scope].
   ///
@@ -59,10 +217,22 @@ class CherryPick {
       throw Exception('Can not open sub scope because scopeName can not split');
     }
 
-    return nameParts.fold(
+    final scope = nameParts.fold(
         openRootScope(),
         (Scope previousValue, String element) =>
             previousValue.openSubScope(element));
+    
+    // Применяем глобальную настройку обнаружения циклических зависимостей
+    if (_globalCycleDetectionEnabled && !scope.isCycleDetectionEnabled) {
+      scope.enableCycleDetection();
+    }
+    
+    // Применяем глобальную настройку обнаружения между скоупами
+    if (_globalCrossScopeCycleDetectionEnabled && !scope.isGlobalCycleDetectionEnabled) {
+      scope.enableGlobalCycleDetection();
+    }
+    
+    return scope;
   }
 
   /// RU: Метод открывает  дочерний [Scope].
@@ -102,4 +272,106 @@ class CherryPick {
       openRootScope().closeSubScope(nameParts[0]);
     }
   }
+
+  /// RU: Глобально включает обнаружение циклических зависимостей между скоупами.
+  /// ENG: Globally enables cross-scope circular dependency detection.
+  ///
+  /// Этот режим обнаруживает циклические зависимости во всей иерархии скоупов.
+  /// This mode detects circular dependencies across the entire scope hierarchy.
+  ///
+  /// Example:
+  /// ```dart
+  /// CherryPick.enableGlobalCrossScopeCycleDetection();
+  /// ```
+  static void enableGlobalCrossScopeCycleDetection() {
+    _globalCrossScopeCycleDetectionEnabled = true;
+    
+    // Включаем для уже существующего root scope, если он есть
+    if (_rootScope != null) {
+      _rootScope!.enableGlobalCycleDetection();
+    }
+  }
+
+  /// RU: Глобально отключает обнаружение циклических зависимостей между скоупами.
+  /// ENG: Globally disables cross-scope circular dependency detection.
+  ///
+  /// Example:
+  /// ```dart
+  /// CherryPick.disableGlobalCrossScopeCycleDetection();
+  /// ```
+  static void disableGlobalCrossScopeCycleDetection() {
+    _globalCrossScopeCycleDetectionEnabled = false;
+    
+    // Отключаем для уже существующего root scope, если он есть
+    if (_rootScope != null) {
+      _rootScope!.disableGlobalCycleDetection();
+    }
+    
+    // Очищаем глобальный детектор
+    GlobalCycleDetector.instance.clear();
+  }
+
+  /// RU: Проверяет, включено ли глобальное обнаружение циклических зависимостей между скоупами.
+  /// ENG: Checks if global cross-scope circular dependency detection is enabled.
+  ///
+  /// return true если включено, false если отключено
+  /// return true if enabled, false if disabled
+  static bool get isGlobalCrossScopeCycleDetectionEnabled => _globalCrossScopeCycleDetectionEnabled;
+
+  /// RU: Возвращает глобальную цепочку разрешения зависимостей.
+  /// ENG: Returns global dependency resolution chain.
+  ///
+  /// Полезно для отладки циклических зависимостей между скоупами.
+  /// Useful for debugging circular dependencies across scopes.
+  ///
+  /// return список имен зависимостей в глобальной цепочке разрешения
+  /// return list of dependency names in global resolution chain
+  static List<String> getGlobalResolutionChain() {
+    return GlobalCycleDetector.instance.globalResolutionChain;
+  }
+
+  /// RU: Очищает все состояние глобального детектора циклических зависимостей.
+  /// ENG: Clears all global circular dependency detector state.
+  ///
+  /// Полезно для тестов и сброса состояния.
+  /// Useful for tests and state reset.
+  static void clearGlobalCycleDetector() {
+    GlobalCycleDetector.reset();
+  }
+
+  /// RU: Создает новый скоуп с автоматически включенным глобальным обнаружением циклических зависимостей.
+  /// ENG: Creates a new scope with automatically enabled global circular dependency detection.
+  ///
+  /// Этот скоуп будет отслеживать циклические зависимости во всей иерархии.
+  /// This scope will track circular dependencies across the entire hierarchy.
+  ///
+  /// Example:
+  /// ```dart
+  /// final scope = CherryPick.openGlobalSafeRootScope();
+  /// // Глобальное обнаружение циклических зависимостей автоматически включено
+  /// ```
+  static Scope openGlobalSafeRootScope() {
+    final scope = openRootScope();
+    scope.enableCycleDetection();
+    scope.enableGlobalCycleDetection();
+    return scope;
+  }
+
+  /// RU: Создает новый дочерний скоуп с автоматически включенным глобальным обнаружением циклических зависимостей.
+  /// ENG: Creates a new child scope with automatically enabled global circular dependency detection.
+  ///
+  /// [scopeName] - имя скоупа
+  /// [scopeName] - scope name
+  ///
+  /// Example:
+  /// ```dart
+  /// final scope = CherryPick.openGlobalSafeScope(scopeName: 'feature.auth');
+  /// // Глобальное обнаружение циклических зависимостей автоматически включено
+  /// ```
+  static Scope openGlobalSafeScope({String scopeName = '', String separator = '.'}) {
+    final scope = openScope(scopeName: scopeName, separator: separator);
+    scope.enableCycleDetection();
+    scope.enableGlobalCycleDetection();
+    return scope;
+  }
 }

cherrypick/lib/src/scope.dart

@@ -11,13 +11,16 @@
 // limitations under the License.
 //
 import 'dart:collection';
+import 'dart:math';
 
 import 'package:cherrypick/src/binding.dart';
+import 'package:cherrypick/src/cycle_detector.dart';
+import 'package:cherrypick/src/global_cycle_detector.dart';
 import 'package:cherrypick/src/module.dart';
 
 Scope openRootScope() => Scope(null);
 
-class Scope {
+class Scope with CycleDetectionMixin, GlobalCycleDetectionMixin {
   final Scope? _parentScope;
 
   /// RU: Метод возвращает родительский [Scope].
@@ -29,10 +32,22 @@ class Scope {
 
   final Map<String, Scope> _scopeMap = HashMap();
 
-  Scope(this._parentScope);
+  Scope(this._parentScope) {
+    // Генерируем уникальный ID для скоупа
+    setScopeId(_generateScopeId());
+  }
 
   final Set<Module> _modulesList = HashSet();
 
+  /// RU: Генерирует уникальный идентификатор для скоупа.
+  /// ENG: Generates unique identifier for scope.
+  String _generateScopeId() {
+    final random = Random();
+    final timestamp = DateTime.now().millisecondsSinceEpoch;
+    final randomPart = random.nextInt(10000);
+    return 'scope_${timestamp}_$randomPart';
+  }
+
   /// RU: Метод открывает дочерний (дополнительный) [Scope].
   ///
   /// ENG: The method opens child (additional) [Scope].
@@ -40,7 +55,17 @@ class Scope {
   /// return [Scope]
   Scope openSubScope(String name) {
     if (!_scopeMap.containsKey(name)) {
-      _scopeMap[name] = Scope(this);
+      final childScope = Scope(this);
+      
+      // Наследуем настройки обнаружения циклических зависимостей
+      if (isCycleDetectionEnabled) {
+        childScope.enableCycleDetection();
+      }
+      if (isGlobalCycleDetectionEnabled) {
+        childScope.enableGlobalCycleDetection();
+      }
+      
+      _scopeMap[name] = childScope;
     }
     return _scopeMap[name]!;
   }
@@ -51,6 +76,13 @@ class Scope {
   ///
   /// return [Scope]
   void closeSubScope(String name) {
+    final childScope = _scopeMap[name];
+    if (childScope != null) {
+      // Очищаем детектор для дочернего скоупа
+      if (childScope.scopeId != null) {
+        GlobalCycleDetector.instance.removeScopeDetector(childScope.scopeId!);
+      }
+    }
     _scopeMap.remove(name);
   }
 
@@ -91,19 +123,59 @@ class Scope {
   /// return - returns an object of type [T] or [StateError]
   ///
   T resolve<T>({String? named, dynamic params}) {
-    var resolved = tryResolve<T>(named: named, params: params);
-    if (resolved != null) {
-      return resolved;
+    // Используем глобальное отслеживание, если включено
+    if (isGlobalCycleDetectionEnabled) {
+      return withGlobalCycleDetection<T>(T, named, () {
+        return _resolveWithLocalDetection<T>(named: named, params: params);
+      });
     } else {
-      throw StateError(
-          'Can\'t resolve dependency `$T`. Maybe you forget register it?');
+      return _resolveWithLocalDetection<T>(named: named, params: params);
     }
   }
 
+  /// RU: Разрешение с локальным детектором циклических зависимостей.
+  /// ENG: Resolution with local circular dependency detector.
+  T _resolveWithLocalDetection<T>({String? named, dynamic params}) {
+    return withCycleDetection<T>(T, named, () {
+      var resolved = _tryResolveInternal<T>(named: named, params: params);
+      if (resolved != null) {
+        return resolved;
+      } else {
+        throw StateError(
+            'Can\'t resolve dependency `$T`. Maybe you forget register it?');
+      }
+    });
+  }
+
   /// RU: Возвращает найденную зависимость типа [T] или null, если она не может быть найдена.
   /// ENG: Returns found dependency of type [T] or null if it cannot be found.
   ///
   T? tryResolve<T>({String? named, dynamic params}) {
+    // Используем глобальное отслеживание, если включено
+    if (isGlobalCycleDetectionEnabled) {
+      return withGlobalCycleDetection<T?>(T, named, () {
+        return _tryResolveWithLocalDetection<T>(named: named, params: params);
+      });
+    } else {
+      return _tryResolveWithLocalDetection<T>(named: named, params: params);
+    }
+  }
+
+  /// RU: Попытка разрешения с локальным детектором циклических зависимостей.
+  /// ENG: Try resolution with local circular dependency detector.
+  T? _tryResolveWithLocalDetection<T>({String? named, dynamic params}) {
+    if (isCycleDetectionEnabled) {
+      return withCycleDetection<T?>(T, named, () {
+        return _tryResolveInternal<T>(named: named, params: params);
+      });
+    } else {
+      return _tryResolveInternal<T>(named: named, params: params);
+    }
+  }
+
+  /// RU: Внутренний метод для разрешения зависимостей без проверки циклических зависимостей.
+  /// ENG: Internal method for dependency resolution without circular dependency checking.
+  T? _tryResolveInternal<T>({String? named, dynamic params}) {
     // 1 Поиск зависимости по всем модулям текущего скоупа
     if (_modulesList.isNotEmpty) {
       for (var module in _modulesList) {
@@ -130,7 +202,7 @@ class Scope {
     }
 
     // 2 Поиск зависимостей в родительском скоупе
-    return _parentScope?.tryResolve(named: named, params: params);
+    return _parentScope?._tryResolveInternal(named: named, params: params);
   }
 
   /// RU: Асинхронно возвращает найденную зависимость, определенную параметром типа [T].
@@ -144,16 +216,56 @@ class Scope {
   /// return - returns an object of type [T] or [StateError]
   ///
   Future<T> resolveAsync<T>({String? named, dynamic params}) async {
-    var resolved = await tryResolveAsync<T>(named: named, params: params);
-    if (resolved != null) {
-      return resolved;
+    // Используем глобальное отслеживание, если включено
+    if (isGlobalCycleDetectionEnabled) {
+      return withGlobalCycleDetection<Future<T>>(T, named, () async {
+        return await _resolveAsyncWithLocalDetection<T>(named: named, params: params);
+      });
     } else {
-      throw StateError(
-          'Can\'t resolve async dependency `$T`. Maybe you forget register it?');
+      return await _resolveAsyncWithLocalDetection<T>(named: named, params: params);
     }
   }
 
+  /// RU: Асинхронное разрешение с локальным детектором циклических зависимостей.
+  /// ENG: Async resolution with local circular dependency detector.
+  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);
+      if (resolved != null) {
+        return resolved;
+      } else {
+        throw StateError(
+            'Can\'t resolve async dependency `$T`. Maybe you forget register it?');
+      }
+    });
+  }
+
   Future<T?> tryResolveAsync<T>({String? named, dynamic params}) async {
+    // Используем глобальное отслеживание, если включено
+    if (isGlobalCycleDetectionEnabled) {
+      return withGlobalCycleDetection<Future<T?>>(T, named, () async {
+        return await _tryResolveAsyncWithLocalDetection<T>(named: named, params: params);
+      });
+    } else {
+      return await _tryResolveAsyncWithLocalDetection<T>(named: named, params: params);
+    }
+  }
+
+  /// RU: Асинхронная попытка разрешения с локальным детектором циклических зависимостей.
+  /// ENG: Async try resolution with local circular dependency detector.
+  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);
+      });
+    } else {
+      return await _tryResolveAsyncInternal<T>(named: named, params: params);
+    }
+  }
+
+  /// RU: Внутренний метод для асинхронного разрешения зависимостей без проверки циклических зависимостей.
+  /// ENG: Internal method for async dependency resolution without circular dependency checking.
+  Future<T?> _tryResolveAsyncInternal<T>({String? named, dynamic params}) async {
     if (_modulesList.isNotEmpty) {
       for (var module in _modulesList) {
         for (var binding in module.bindingSet) {
@@ -178,6 +290,6 @@ class Scope {
         }
       }
     }
-    return _parentScope?.tryResolveAsync(named: named, params: params);
+    return _parentScope?._tryResolveAsyncInternal(named: named, params: params);
   }
 }

cherrypick/pubspec.yaml

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

cherrypick/test/src/cross_scope_cycle_test.dart

@@ -0,0 +1,158 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Cross-Scope Circular Dependency Detection', () {
+    tearDown(() {
+      CherryPick.closeRootScope();
+      CherryPick.disableGlobalCycleDetection();
+    });
+
+    test('should detect circular dependency across parent-child scopes', () {
+      // Создаем родительский скоуп с сервисом A
+      final parentScope = CherryPick.openSafeRootScope();
+      parentScope.installModules([ParentScopeModule()]);
+
+      // Создаем дочерний скоуп с сервисом B, который зависит от A
+      final childScope = parentScope.openSubScope('child');
+      childScope.enableCycleDetection();
+      childScope.installModules([ChildScopeModule()]);
+
+      // Сервис A в родительском скоупе пытается получить сервис B из дочернего скоупа
+      // Это создает циклическую зависимость между скоупами
+      expect(
+        () => parentScope.resolve<CrossScopeServiceA>(),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+
+    test('should detect circular dependency in complex scope hierarchy', () {
+      final rootScope = CherryPick.openSafeRootScope();
+      final level1Scope = rootScope.openSubScope('level1');
+      final level2Scope = level1Scope.openSubScope('level2');
+      
+      level1Scope.enableCycleDetection();
+      level2Scope.enableCycleDetection();
+
+      // Устанавливаем модули на разных уровнях
+      rootScope.installModules([RootLevelModule()]);
+      level1Scope.installModules([Level1Module()]);
+      level2Scope.installModules([Level2Module()]);
+
+      // Попытка разрешить зависимость, которая создает цикл через все уровни
+      expect(
+        () => level2Scope.resolve<Level2Service>(),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+
+    test('current implementation limitation - may not detect cross-scope cycles', () {
+      // Этот тест демонстрирует ограничение текущей реализации
+      final parentScope = CherryPick.openRootScope();
+      parentScope.enableCycleDetection();
+      
+      final childScope = parentScope.openSubScope('child');
+      // НЕ включаем cycle detection для дочернего скоупа
+      
+      parentScope.installModules([ParentScopeModule()]);
+      childScope.installModules([ChildScopeModule()]);
+
+      // В текущей реализации это может не обнаружить циклическую зависимость
+      // если детекторы работают независимо в каждом скоупе
+      try {
+        // ignore: unused_local_variable
+        final service = parentScope.resolve<CrossScopeServiceA>();
+        // Если мы дошли сюда, значит циклическая зависимость не была обнаружена
+        print('Циклическая зависимость между скоупами не обнаружена');
+      } catch (e) {
+        if (e is CircularDependencyException) {
+          print('Циклическая зависимость обнаружена: ${e.message}');
+        } else {
+          print('Другая ошибка: $e');
+        }
+      }
+    });
+  });
+}
+
+// Тестовые сервисы для демонстрации циклических зависимостей между скоупами
+
+class CrossScopeServiceA {
+  final CrossScopeServiceB serviceB;
+  CrossScopeServiceA(this.serviceB);
+}
+
+class CrossScopeServiceB {
+  final CrossScopeServiceA serviceA;
+  CrossScopeServiceB(this.serviceA);
+}
+
+class ParentScopeModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<CrossScopeServiceA>().toProvide(() {
+      // Пытаемся получить сервис B из дочернего скоупа
+      final childScope = currentScope.openSubScope('child');
+      return CrossScopeServiceA(childScope.resolve<CrossScopeServiceB>());
+    });
+  }
+}
+
+class ChildScopeModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<CrossScopeServiceB>().toProvide(() {
+      // Пытаемся получить сервис A из родительского скоупа
+      final parentScope = currentScope.parentScope!;
+      return CrossScopeServiceB(parentScope.resolve<CrossScopeServiceA>());
+    });
+  }
+}
+
+// Сервисы для сложной иерархии скоупов
+
+class RootLevelService {
+  final Level1Service level1Service;
+  RootLevelService(this.level1Service);
+}
+
+class Level1Service {
+  final Level2Service level2Service;
+  Level1Service(this.level2Service);
+}
+
+class Level2Service {
+  final RootLevelService rootService;
+  Level2Service(this.rootService);
+}
+
+class RootLevelModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<RootLevelService>().toProvide(() {
+      final level1Scope = currentScope.openSubScope('level1');
+      return RootLevelService(level1Scope.resolve<Level1Service>());
+    });
+  }
+}
+
+class Level1Module extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<Level1Service>().toProvide(() {
+      final level2Scope = currentScope.openSubScope('level2');
+      return Level1Service(level2Scope.resolve<Level2Service>());
+    });
+  }
+}
+
+class Level2Module extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<Level2Service>().toProvide(() {
+      // Идем к корневому скоупу через цепочку родителей
+      var rootScope = currentScope.parentScope?.parentScope;
+      return Level2Service(rootScope!.resolve<RootLevelService>());
+    });
+  }
+}

cherrypick/test/src/cycle_detector_test.dart

@@ -0,0 +1,213 @@
+import 'package:cherrypick/src/cycle_detector.dart';
+import 'package:cherrypick/src/module.dart';
+import 'package:cherrypick/src/scope.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('CycleDetector', () {
+    late CycleDetector detector;
+
+    setUp(() {
+      detector = CycleDetector();
+    });
+
+    test('should detect simple circular dependency', () {
+      detector.startResolving<String>();
+      
+      expect(
+        () => detector.startResolving<String>(),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+
+    test('should detect circular dependency with named bindings', () {
+      detector.startResolving<String>(named: 'test');
+      
+      expect(
+        () => detector.startResolving<String>(named: 'test'),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+
+    test('should allow different types to be resolved simultaneously', () {
+      detector.startResolving<String>();
+      detector.startResolving<int>();
+      
+      expect(() => detector.finishResolving<int>(), returnsNormally);
+      expect(() => detector.finishResolving<String>(), returnsNormally);
+    });
+
+    test('should detect complex circular dependency chain', () {
+      detector.startResolving<String>();
+      detector.startResolving<int>();
+      detector.startResolving<bool>();
+      
+      expect(
+        () => detector.startResolving<String>(),
+        throwsA(predicate((e) => 
+          e is CircularDependencyException &&
+          e.dependencyChain.contains('String') &&
+          e.dependencyChain.length > 1
+        )),
+      );
+    });
+
+    test('should clear state properly', () {
+      detector.startResolving<String>();
+      detector.clear();
+      
+      expect(() => detector.startResolving<String>(), returnsNormally);
+    });
+
+    test('should track resolution history correctly', () {
+      detector.startResolving<String>();
+      detector.startResolving<int>();
+      
+      expect(detector.currentResolutionChain, contains('String'));
+      expect(detector.currentResolutionChain, contains('int'));
+      expect(detector.currentResolutionChain.length, equals(2));
+      
+      detector.finishResolving<int>();
+      expect(detector.currentResolutionChain.length, equals(1));
+      expect(detector.currentResolutionChain, contains('String'));
+    });
+  });
+
+  group('Scope with Cycle Detection', () {
+    test('should detect circular dependency in real scenario', () {
+      final scope = Scope(null);
+      scope.enableCycleDetection();
+      
+      // Создаем циклическую зависимость: A зависит от B, B зависит от A
+      scope.installModules([
+        CircularModuleA(),
+        CircularModuleB(),
+      ]);
+
+      expect(
+        () => scope.resolve<ServiceA>(),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+
+    test('should work normally without cycle detection enabled', () {
+      final scope = Scope(null);
+      // Не включаем обнаружение циклических зависимостей
+      
+      scope.installModules([
+        SimpleModule(),
+      ]);
+
+      expect(() => scope.resolve<SimpleService>(), returnsNormally);
+      expect(scope.resolve<SimpleService>(), isA<SimpleService>());
+    });
+
+    test('should allow disabling cycle detection', () {
+      final scope = Scope(null);
+      scope.enableCycleDetection();
+      expect(scope.isCycleDetectionEnabled, isTrue);
+      
+      scope.disableCycleDetection();
+      expect(scope.isCycleDetectionEnabled, isFalse);
+    });
+
+    test('should handle named dependencies in cycle detection', () {
+      final scope = Scope(null);
+      scope.enableCycleDetection();
+      
+      scope.installModules([
+        NamedCircularModule(),
+      ]);
+
+      expect(
+        () => scope.resolve<String>(named: 'circular'),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+
+    test('should detect cycles in async resolution', () async {
+      final scope = Scope(null);
+      scope.enableCycleDetection();
+      
+      scope.installModules([
+        AsyncCircularModule(),
+      ]);
+
+      expect(
+        () => scope.resolveAsync<AsyncServiceA>(),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+  });
+}
+
+// Test services and modules for circular dependency testing
+
+class ServiceA {
+  final ServiceB serviceB;
+  ServiceA(this.serviceB);
+}
+
+class ServiceB {
+  final ServiceA serviceA;
+  ServiceB(this.serviceA);
+}
+
+class CircularModuleA extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<ServiceA>().toProvide(() => ServiceA(currentScope.resolve<ServiceB>()));
+  }
+}
+
+class CircularModuleB extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<ServiceB>().toProvide(() => ServiceB(currentScope.resolve<ServiceA>()));
+  }
+}
+
+class SimpleService {
+  SimpleService();
+}
+
+class SimpleModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<SimpleService>().toProvide(() => SimpleService());
+  }
+}
+
+class NamedCircularModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<String>()
+        .withName('circular')
+        .toProvide(() => currentScope.resolve<String>(named: 'circular'));
+  }
+}
+
+class AsyncServiceA {
+  final AsyncServiceB serviceB;
+  AsyncServiceA(this.serviceB);
+}
+
+class AsyncServiceB {
+  final AsyncServiceA serviceA;
+  AsyncServiceB(this.serviceA);
+}
+
+class AsyncCircularModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<AsyncServiceA>().toProvideAsync(() async {
+      final serviceB = await currentScope.resolveAsync<AsyncServiceB>();
+      return AsyncServiceA(serviceB);
+    });
+    
+    bind<AsyncServiceB>().toProvideAsync(() async {
+      final serviceA = await currentScope.resolveAsync<AsyncServiceA>();
+      return AsyncServiceB(serviceA);
+    });
+  }
+}

cherrypick/test/src/global_cycle_detection_test.dart

@@ -0,0 +1,274 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Global Cycle Detection', () {
+    setUp(() {
+      // Сбрасываем состояние перед каждым тестом
+      CherryPick.closeRootScope();
+      CherryPick.disableGlobalCycleDetection();
+      CherryPick.disableGlobalCrossScopeCycleDetection();
+      CherryPick.clearGlobalCycleDetector();
+    });
+
+    tearDown(() {
+      // Очищаем состояние после каждого теста
+      CherryPick.closeRootScope();
+      CherryPick.disableGlobalCycleDetection();
+      CherryPick.disableGlobalCrossScopeCycleDetection();
+      CherryPick.clearGlobalCycleDetector();
+    });
+
+    group('Global Cross-Scope Cycle Detection', () {
+      test('should enable global cross-scope cycle detection', () {
+        expect(CherryPick.isGlobalCrossScopeCycleDetectionEnabled, isFalse);
+        
+        CherryPick.enableGlobalCrossScopeCycleDetection();
+        
+        expect(CherryPick.isGlobalCrossScopeCycleDetectionEnabled, isTrue);
+      });
+
+      test('should disable global cross-scope cycle detection', () {
+        CherryPick.enableGlobalCrossScopeCycleDetection();
+        expect(CherryPick.isGlobalCrossScopeCycleDetectionEnabled, isTrue);
+        
+        CherryPick.disableGlobalCrossScopeCycleDetection();
+        
+        expect(CherryPick.isGlobalCrossScopeCycleDetectionEnabled, isFalse);
+      });
+
+      test('should automatically enable global cycle detection for new root scope', () {
+        CherryPick.enableGlobalCrossScopeCycleDetection();
+        
+        final scope = CherryPick.openRootScope();
+        
+        expect(scope.isGlobalCycleDetectionEnabled, isTrue);
+      });
+
+      test('should automatically enable global cycle detection for existing root scope', () {
+        final scope = CherryPick.openRootScope();
+        expect(scope.isGlobalCycleDetectionEnabled, isFalse);
+        
+        CherryPick.enableGlobalCrossScopeCycleDetection();
+        
+        expect(scope.isGlobalCycleDetectionEnabled, isTrue);
+      });
+    });
+
+    group('Global Safe Scope Creation', () {
+      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', () {
+        final scope = CherryPick.openGlobalSafeScope(scopeName: 'feature.global');
+        
+        expect(scope.isCycleDetectionEnabled, isTrue);
+        expect(scope.isGlobalCycleDetectionEnabled, isTrue);
+      });
+    });
+
+    group('Cross-Scope Circular Dependency Detection', () {
+      test('should detect circular dependency across parent-child scopes', () {
+        final parentScope = CherryPick.openGlobalSafeRootScope();
+        parentScope.installModules([GlobalParentModule()]);
+
+        final childScope = parentScope.openSubScope('child');
+        childScope.installModules([GlobalChildModule()]);
+
+        expect(
+          () => parentScope.resolve<GlobalServiceA>(),
+          throwsA(isA<CircularDependencyException>()),
+        );
+      });
+
+      test('should detect circular dependency in complex scope hierarchy', () {
+        final rootScope = CherryPick.openGlobalSafeRootScope();
+        final level1Scope = rootScope.openSubScope('level1');
+        final level2Scope = level1Scope.openSubScope('level2');
+
+        // Устанавливаем модули на разных уровнях
+        rootScope.installModules([GlobalRootModule()]);
+        level1Scope.installModules([GlobalLevel1Module()]);
+        level2Scope.installModules([GlobalLevel2Module()]);
+
+        expect(
+          () => level2Scope.resolve<GlobalLevel2Service>(),
+          throwsA(isA<CircularDependencyException>()),
+        );
+      });
+
+      test('should provide detailed global resolution chain in exception', () {
+        final scope = CherryPick.openGlobalSafeRootScope();
+        scope.installModules([GlobalParentModule()]);
+        
+        final childScope = scope.openSubScope('child');
+        childScope.installModules([GlobalChildModule()]);
+
+        try {
+          scope.resolve<GlobalServiceA>();
+          fail('Expected CircularDependencyException');
+        } catch (e) {
+          expect(e, isA<CircularDependencyException>());
+          final circularError = e as CircularDependencyException;
+          
+          // Проверяем, что цепочка содержит информацию о скоупах
+          expect(circularError.dependencyChain, isNotEmpty);
+          expect(circularError.dependencyChain.length, greaterThan(1));
+          
+          // Цепочка должна содержать оба сервиса
+          final chainString = circularError.dependencyChain.join(' -> ');
+          expect(chainString, contains('GlobalServiceA'));
+          expect(chainString, contains('GlobalServiceB'));
+        }
+      });
+
+      test('should track global resolution chain', () {
+        final scope = CherryPick.openGlobalSafeRootScope();
+        scope.installModules([SimpleGlobalModule()]);
+
+        // До разрешения цепочка должна быть пустой
+        expect(CherryPick.getGlobalResolutionChain(), isEmpty);
+
+        final service = scope.resolve<SimpleGlobalService>();
+        expect(service, isA<SimpleGlobalService>());
+
+        // После разрешения цепочка должна быть очищена
+        expect(CherryPick.getGlobalResolutionChain(), isEmpty);
+      });
+
+      test('should clear global cycle detector state', () {
+        CherryPick.enableGlobalCrossScopeCycleDetection();
+        // ignore: unused_local_variable
+        final scope = CherryPick.openGlobalSafeRootScope();
+        
+        expect(CherryPick.getGlobalResolutionChain(), isEmpty);
+        
+        CherryPick.clearGlobalCycleDetector();
+        
+        // После очистки детектор должен быть сброшен
+        expect(CherryPick.getGlobalResolutionChain(), isEmpty);
+      });
+    });
+
+    group('Inheritance of Global Settings', () {
+      test('should inherit global cycle detection in child scopes', () {
+        CherryPick.enableGlobalCrossScopeCycleDetection();
+        
+        final parentScope = CherryPick.openRootScope();
+        final childScope = parentScope.openSubScope('child');
+        
+        expect(parentScope.isGlobalCycleDetectionEnabled, isTrue);
+        expect(childScope.isGlobalCycleDetectionEnabled, isTrue);
+      });
+
+      test('should inherit both local and global cycle detection', () {
+        CherryPick.enableGlobalCycleDetection();
+        CherryPick.enableGlobalCrossScopeCycleDetection();
+        
+        final scope = CherryPick.openScope(scopeName: 'feature.test');
+        
+        expect(scope.isCycleDetectionEnabled, isTrue);
+        expect(scope.isGlobalCycleDetectionEnabled, isTrue);
+      });
+    });
+  });
+}
+
+// Test services for global circular dependency testing
+
+class GlobalServiceA {
+  final GlobalServiceB serviceB;
+  GlobalServiceA(this.serviceB);
+}
+
+class GlobalServiceB {
+  final GlobalServiceA serviceA;
+  GlobalServiceB(this.serviceA);
+}
+
+class GlobalParentModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<GlobalServiceA>().toProvide(() {
+      // Получаем сервис B из дочернего скоупа
+      final childScope = currentScope.openSubScope('child');
+      return GlobalServiceA(childScope.resolve<GlobalServiceB>());
+    });
+  }
+}
+
+class GlobalChildModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<GlobalServiceB>().toProvide(() {
+      // Получаем сервис A из родительского скоупа
+      final parentScope = currentScope.parentScope!;
+      return GlobalServiceB(parentScope.resolve<GlobalServiceA>());
+    });
+  }
+}
+
+// Services for complex hierarchy testing
+
+class GlobalRootService {
+  final GlobalLevel1Service level1Service;
+  GlobalRootService(this.level1Service);
+}
+
+class GlobalLevel1Service {
+  final GlobalLevel2Service level2Service;
+  GlobalLevel1Service(this.level2Service);
+}
+
+class GlobalLevel2Service {
+  final GlobalRootService rootService;
+  GlobalLevel2Service(this.rootService);
+}
+
+class GlobalRootModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<GlobalRootService>().toProvide(() {
+      final level1Scope = currentScope.openSubScope('level1');
+      return GlobalRootService(level1Scope.resolve<GlobalLevel1Service>());
+    });
+  }
+}
+
+class GlobalLevel1Module extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<GlobalLevel1Service>().toProvide(() {
+      final level2Scope = currentScope.openSubScope('level2');
+      return GlobalLevel1Service(level2Scope.resolve<GlobalLevel2Service>());
+    });
+  }
+}
+
+class GlobalLevel2Module extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<GlobalLevel2Service>().toProvide(() {
+      // Идем к корневому скоупу через цепочку родителей
+      var rootScope = currentScope.parentScope?.parentScope;
+      return GlobalLevel2Service(rootScope!.resolve<GlobalRootService>());
+    });
+  }
+}
+
+// Simple service for non-circular testing
+
+class SimpleGlobalService {
+  SimpleGlobalService();
+}
+
+class SimpleGlobalModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<SimpleGlobalService>().toProvide(() => SimpleGlobalService());
+  }
+}

cherrypick/test/src/helper_cycle_detection_test.dart

@@ -0,0 +1,240 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('CherryPick Cycle Detection Helper Methods', () {
+    setUp(() {
+      // Сбрасываем состояние перед каждым тестом
+      CherryPick.closeRootScope();
+      CherryPick.disableGlobalCycleDetection();
+    });
+
+    tearDown(() {
+      // Очищаем состояние после каждого теста
+      CherryPick.closeRootScope();
+      CherryPick.disableGlobalCycleDetection();
+    });
+
+    group('Global Cycle Detection', () {
+      test('should enable global cycle detection', () {
+        expect(CherryPick.isGlobalCycleDetectionEnabled, isFalse);
+        
+        CherryPick.enableGlobalCycleDetection();
+        
+        expect(CherryPick.isGlobalCycleDetectionEnabled, isTrue);
+      });
+
+      test('should disable global cycle detection', () {
+        CherryPick.enableGlobalCycleDetection();
+        expect(CherryPick.isGlobalCycleDetectionEnabled, isTrue);
+        
+        CherryPick.disableGlobalCycleDetection();
+        
+        expect(CherryPick.isGlobalCycleDetectionEnabled, isFalse);
+      });
+
+      test('should automatically enable cycle detection for new root scope when global is enabled', () {
+        CherryPick.enableGlobalCycleDetection();
+        
+        final scope = CherryPick.openRootScope();
+        
+        expect(scope.isCycleDetectionEnabled, isTrue);
+      });
+
+      test('should automatically enable cycle detection for existing root scope when global is enabled', () {
+        final scope = CherryPick.openRootScope();
+        expect(scope.isCycleDetectionEnabled, isFalse);
+        
+        CherryPick.enableGlobalCycleDetection();
+        
+        expect(scope.isCycleDetectionEnabled, isTrue);
+      });
+
+      test('should automatically disable cycle detection for existing root scope when global is disabled', () {
+        CherryPick.enableGlobalCycleDetection();
+        final scope = CherryPick.openRootScope();
+        expect(scope.isCycleDetectionEnabled, isTrue);
+        
+        CherryPick.disableGlobalCycleDetection();
+        
+        expect(scope.isCycleDetectionEnabled, isFalse);
+      });
+
+      test('should apply global setting to sub-scopes', () {
+        CherryPick.enableGlobalCycleDetection();
+        
+        final scope = CherryPick.openScope(scopeName: 'test.subscope');
+        
+        expect(scope.isCycleDetectionEnabled, isTrue);
+      });
+    });
+
+    group('Scope-specific Cycle Detection', () {
+      test('should enable cycle detection for root scope', () {
+        final scope = CherryPick.openRootScope();
+        expect(scope.isCycleDetectionEnabled, isFalse);
+        
+        CherryPick.enableCycleDetectionForScope();
+        
+        expect(CherryPick.isCycleDetectionEnabledForScope(), isTrue);
+        expect(scope.isCycleDetectionEnabled, isTrue);
+      });
+
+      test('should disable cycle detection for root scope', () {
+        CherryPick.enableCycleDetectionForScope();
+        expect(CherryPick.isCycleDetectionEnabledForScope(), isTrue);
+        
+        CherryPick.disableCycleDetectionForScope();
+        
+        expect(CherryPick.isCycleDetectionEnabledForScope(), isFalse);
+      });
+
+      test('should enable cycle detection for specific scope', () {
+        final scopeName = 'feature.auth';
+        CherryPick.openScope(scopeName: scopeName);
+        
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName), isFalse);
+        
+        CherryPick.enableCycleDetectionForScope(scopeName: scopeName);
+        
+        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);
+        
+        CherryPick.disableCycleDetectionForScope(scopeName: scopeName);
+        
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName), isFalse);
+      });
+    });
+
+    group('Safe Scope Creation', () {
+      test('should create safe root scope with cycle detection enabled', () {
+        final scope = CherryPick.openSafeRootScope();
+        
+        expect(scope.isCycleDetectionEnabled, isTrue);
+      });
+
+      test('should create safe sub-scope with cycle detection enabled', () {
+        final scope = CherryPick.openSafeScope(scopeName: 'feature.safe');
+        
+        expect(scope.isCycleDetectionEnabled, isTrue);
+      });
+
+      test('safe scope should work independently of global setting', () {
+        // Глобальная настройка отключена
+        expect(CherryPick.isGlobalCycleDetectionEnabled, isFalse);
+        
+        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', () {
+        CherryPick.openRootScope();
+        
+        final chain = CherryPick.getCurrentResolutionChain();
+        
+        expect(chain, isEmpty);
+      });
+
+      test('should return empty resolution chain for scope with cycle detection but no active resolution', () {
+        CherryPick.enableCycleDetectionForScope();
+        
+        final chain = CherryPick.getCurrentResolutionChain();
+        
+        expect(chain, isEmpty);
+      });
+
+      test('should track resolution chain for specific scope', () {
+        final scopeName = 'feature.tracking';
+        CherryPick.enableCycleDetectionForScope(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', () {
+        CherryPick.enableGlobalCycleDetection();
+        
+        final scope = CherryPick.openRootScope();
+        scope.installModules([CircularTestModule()]);
+        
+        expect(
+          () => scope.resolve<CircularServiceA>(),
+          throwsA(isA<CircularDependencyException>()),
+        );
+      });
+
+      test('should detect circular dependency with safe scope', () {
+        final scope = CherryPick.openSafeRootScope();
+        scope.installModules([CircularTestModule()]);
+        
+        expect(
+          () => scope.resolve<CircularServiceA>(),
+          throwsA(isA<CircularDependencyException>()),
+        );
+      });
+
+      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>()));
+      });
+    });
+
+    group('Scope Name Handling', () {
+      test('should handle empty scope name as root scope', () {
+        CherryPick.enableCycleDetectionForScope(scopeName: '');
+        
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: ''), isTrue);
+        expect(CherryPick.isCycleDetectionEnabledForScope(), isTrue);
+      });
+
+      test('should handle complex scope names', () {
+        final complexScopeName = 'app.feature.auth.login';
+        CherryPick.enableCycleDetectionForScope(scopeName: complexScopeName);
+        
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: complexScopeName), isTrue);
+      });
+
+      test('should handle custom separator', () {
+        final scopeName = 'app/feature/auth';
+        CherryPick.enableCycleDetectionForScope(scopeName: scopeName, separator: '/');
+        
+        expect(CherryPick.isCycleDetectionEnabledForScope(scopeName: scopeName, separator: '/'), isTrue);
+      });
+    });
+  });
+}
+
+// Test services for circular dependency testing
+class CircularServiceA {
+  final CircularServiceB serviceB;
+  CircularServiceA(this.serviceB);
+}
+
+class CircularServiceB {
+  final CircularServiceA serviceA;
+  CircularServiceB(this.serviceA);
+}
+
+class CircularTestModule extends Module {
+  @override
+  void builder(Scope currentScope) {
+    bind<CircularServiceA>().toProvide(() => CircularServiceA(currentScope.resolve<CircularServiceB>()));
+    bind<CircularServiceB>().toProvide(() => CircularServiceB(currentScope.resolve<CircularServiceA>()));
+  }
+}

cherrypick_flutter/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.1.3-dev.1
+
+ - Update a dependency to the latest release.
+
+## 1.1.3-dev.0
+
+ - **FIX**: update deps.
+
 ## 1.1.2
 
  - Graduate package to a stable release. See pre-releases prior to this version for changelog entries.

cherrypick_flutter/pubspec.yaml

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

doc/cycle_detection.en.md

@@ -0,0 +1,572 @@
+# Circular Dependency Detection
+
+CherryPick provides robust circular dependency detection to prevent infinite loops and stack overflow errors in your dependency injection setup.
+
+## What are Circular Dependencies?
+
+Circular dependencies occur when two or more services depend on each other directly or indirectly, creating a cycle in the dependency graph.
+
+### Example of circular dependencies within a scope
+
+```dart
+class UserService {
+  final OrderService orderService;
+  UserService(this.orderService);
+}
+
+class OrderService {
+  final UserService userService;
+  OrderService(this.userService);
+}
+```
+
+### Example of circular dependencies between scopes
+
+```dart
+// In parent scope
+class ParentService {
+  final ChildService childService;
+  ParentService(this.childService); // Gets from child scope
+}
+
+// In child scope
+class ChildService {
+  final ParentService parentService;
+  ChildService(this.parentService); // Gets from parent scope
+}
+```
+
+## Detection Types
+
+### 🔍 Local Detection
+
+Detects circular dependencies within a single scope. Fast and efficient.
+
+### 🌐 Global Detection
+
+Detects circular dependencies across the entire scope hierarchy. Slower but provides complete protection.
+
+## Usage
+
+### Local Detection
+
+```dart
+final scope = Scope(null);
+scope.enableCycleDetection(); // Enable local detection
+
+scope.installModules([
+  Module((bind) {
+    bind<UserService>().to((scope) => UserService(scope.resolve<OrderService>()));
+    bind<OrderService>().to((scope) => OrderService(scope.resolve<UserService>()));
+  }),
+]);
+
+try {
+  final userService = scope.resolve<UserService>(); // Will throw CircularDependencyException
+} catch (e) {
+  print(e); // CircularDependencyException: Circular dependency detected
+}
+```
+
+### Global Detection
+
+```dart
+// Enable global detection for all scopes
+CherryPick.enableGlobalCrossScopeCycleDetection();
+
+final rootScope = CherryPick.openGlobalSafeRootScope();
+final childScope = rootScope.openSubScope();
+
+// Configure dependencies that create cross-scope cycles
+rootScope.installModules([
+  Module((bind) {
+    bind<ParentService>().to((scope) => ParentService(childScope.resolve<ChildService>()));
+  }),
+]);
+
+childScope.installModules([
+  Module((bind) {
+    bind<ChildService>().to((scope) => ChildService(rootScope.resolve<ParentService>()));
+  }),
+]);
+
+try {
+  final parentService = rootScope.resolve<ParentService>(); // Will throw CircularDependencyException
+} catch (e) {
+  print(e); // CircularDependencyException with detailed chain information
+}
+```
+
+## CherryPick Helper API
+
+### Global Settings
+
+```dart
+// Enable/disable local detection globally
+CherryPick.enableGlobalCycleDetection();
+CherryPick.disableGlobalCycleDetection();
+
+// Enable/disable global cross-scope detection
+CherryPick.enableGlobalCrossScopeCycleDetection();
+CherryPick.disableGlobalCrossScopeCycleDetection();
+
+// Check current settings
+bool localEnabled = CherryPick.isGlobalCycleDetectionEnabled;
+bool globalEnabled = CherryPick.isGlobalCrossScopeCycleDetectionEnabled;
+```
+
+### Per-Scope Settings
+
+```dart
+// Enable/disable for specific scope
+CherryPick.enableCycleDetectionForScope(scope);
+CherryPick.disableCycleDetectionForScope(scope);
+
+// Enable/disable global detection for specific scope
+CherryPick.enableGlobalCycleDetectionForScope(scope);
+CherryPick.disableGlobalCycleDetectionForScope(scope);
+```
+
+### Safe Scope Creation
+
+```dart
+// Create scopes with detection automatically enabled
+final safeRootScope = CherryPick.openSafeRootScope(); // Local detection enabled
+final globalSafeRootScope = CherryPick.openGlobalSafeRootScope(); // Both local and global enabled
+final safeSubScope = CherryPick.openSafeSubScope(parentScope); // Inherits parent settings
+```
+
+## Performance Considerations
+
+| Detection Type | Overhead | Recommended Usage |
+|----------------|----------|-------------------|
+| **Local** | Minimal (~5%) | Development, Testing |
+| **Global** | Moderate (~15%) | Complex hierarchies, Critical features |
+| **Disabled** | None | Production (after testing) |
+
+### Recommendations
+
+- **Development**: Enable both local and global detection for maximum safety
+- **Testing**: Keep detection enabled to catch issues early
+- **Production**: Consider disabling for performance, but only after thorough testing
+
+```dart
+import 'package:flutter/foundation.dart';
+
+void configureCycleDetection() {
+  if (kDebugMode) {
+    // Enable full protection in debug mode
+    CherryPick.enableGlobalCycleDetection();
+    CherryPick.enableGlobalCrossScopeCycleDetection();
+  } else {
+    // Disable in release mode for performance
+    CherryPick.disableGlobalCycleDetection();
+    CherryPick.disableGlobalCrossScopeCycleDetection();
+  }
+}
+```
+
+## Architectural Patterns
+
+### Repository Pattern
+
+```dart
+// ✅ Correct: Repository doesn't depend on service
+class UserRepository {
+  final ApiClient apiClient;
+  UserRepository(this.apiClient);
+}
+
+class UserService {
+  final UserRepository repository;
+  UserService(this.repository);
+}
+
+// ❌ Incorrect: Circular dependency
+class UserRepository {
+  final UserService userService; // Don't do this!
+  UserRepository(this.userService);
+}
+```
+
+### Mediator Pattern
+
+```dart
+// ✅ Correct: Use mediator to break cycles
+abstract class EventBus {
+  void publish<T>(T event);
+  Stream<T> listen<T>();
+}
+
+class UserService {
+  final EventBus eventBus;
+  UserService(this.eventBus);
+  
+  void createUser(User user) {
+    // ... create user logic
+    eventBus.publish(UserCreatedEvent(user));
+  }
+}
+
+class OrderService {
+  final EventBus eventBus;
+  OrderService(this.eventBus) {
+    eventBus.listen<UserCreatedEvent>().listen(_onUserCreated);
+  }
+  
+  void _onUserCreated(UserCreatedEvent event) {
+    // React to user creation without direct dependency
+  }
+}
+```
+
+## Scope Hierarchy Best Practices
+
+### Proper Dependency Flow
+
+```dart
+// ✅ Correct: Dependencies flow downward in hierarchy
+// Root Scope: Core services
+final rootScope = CherryPick.openGlobalSafeRootScope();
+rootScope.installModules([
+  Module((bind) {
+    bind<DatabaseService>().singleton((scope) => DatabaseService());
+    bind<ApiClient>().singleton((scope) => ApiClient());
+  }),
+]);
+
+// Feature Scope: Feature-specific services
+final featureScope = rootScope.openSubScope();
+featureScope.installModules([
+  Module((bind) {
+    bind<UserRepository>().to((scope) => UserRepository(scope.resolve<ApiClient>()));
+    bind<UserService>().to((scope) => UserService(scope.resolve<UserRepository>()));
+  }),
+]);
+
+// UI Scope: UI-specific services
+final uiScope = featureScope.openSubScope();
+uiScope.installModules([
+  Module((bind) {
+    bind<UserController>().to((scope) => UserController(scope.resolve<UserService>()));
+  }),
+]);
+```
+
+### Avoid Cross-Scope Dependencies
+
+```dart
+// ❌ Incorrect: Child scope depending on parent's specific services
+childScope.installModules([
+  Module((bind) {
+    bind<ChildService>().to((scope) => 
+      ChildService(rootScope.resolve<ParentService>()) // Risky!
+    );
+  }),
+]);
+
+// ✅ Correct: Use interfaces and proper dependency injection
+abstract class IParentService {
+  void doSomething();
+}
+
+class ParentService implements IParentService {
+  void doSomething() { /* implementation */ }
+}
+
+// In root scope
+rootScope.installModules([
+  Module((bind) {
+    bind<IParentService>().to((scope) => ParentService());
+  }),
+]);
+
+// In child scope - resolve through normal hierarchy
+childScope.installModules([
+  Module((bind) {
+    bind<ChildService>().to((scope) => 
+      ChildService(scope.resolve<IParentService>()) // Safe!
+    );
+  }),
+]);
+```
+
+## Debug Mode
+
+### Resolution Chain Tracking
+
+```dart
+// Enable debug mode to track resolution chains
+final scope = CherryPick.openGlobalSafeRootScope();
+
+// Access current resolution chain for debugging
+print('Current resolution chain: ${scope.currentResolutionChain}');
+
+// Access global resolution chain
+print('Global resolution chain: ${GlobalCycleDetector.instance.currentGlobalResolutionChain}');
+```
+
+### Exception Details
+
+```dart
+try {
+  final service = scope.resolve<CircularService>();
+} on CircularDependencyException catch (e) {
+  print('Error: ${e.message}');
+  print('Dependency chain: ${e.dependencyChain.join(' -> ')}');
+  
+  // For global detection, additional context is available
+  if (e.message.contains('cross-scope')) {
+    print('This is a cross-scope circular dependency');
+  }
+}
+```
+
+## Testing Integration
+
+### Unit Tests
+
+```dart
+import 'package:test/test.dart';
+import 'package:cherrypick/cherrypick.dart';
+
+void main() {
+  group('Circular Dependency Detection', () {
+    setUp(() {
+      // Enable detection for tests
+      CherryPick.enableGlobalCycleDetection();
+      CherryPick.enableGlobalCrossScopeCycleDetection();
+    });
+    
+    tearDown(() {
+      // Clean up after tests
+      CherryPick.disableGlobalCycleDetection();
+      CherryPick.disableGlobalCrossScopeCycleDetection();
+    });
+    
+    test('should detect circular dependency', () {
+      final scope = CherryPick.openGlobalSafeRootScope();
+      
+      scope.installModules([
+        Module((bind) {
+          bind<ServiceA>().to((scope) => ServiceA(scope.resolve<ServiceB>()));
+          bind<ServiceB>().to((scope) => ServiceB(scope.resolve<ServiceA>()));
+        }),
+      ]);
+      
+      expect(
+        () => scope.resolve<ServiceA>(),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+  });
+}
+```
+
+### Integration Tests
+
+```dart
+testWidgets('should handle circular dependencies in widget tree', (tester) async {
+  // Enable detection
+  CherryPick.enableGlobalCycleDetection();
+  
+  await tester.pumpWidget(
+    CherryPickProvider(
+      create: () {
+        final scope = CherryPick.openGlobalSafeRootScope();
+        // Configure modules that might have cycles
+        return scope;
+      },
+      child: MyApp(),
+    ),
+  );
+  
+  // Test that circular dependencies are properly handled
+  expect(find.text('Error: Circular dependency detected'), findsNothing);
+});
+```
+
+## Migration Guide
+
+### From Version 2.1.x to 2.2.x
+
+1. **Update dependencies**:
+   ```yaml
+   dependencies:
+     cherrypick: ^2.2.0
+   ```
+
+2. **Enable detection in existing code**:
+   ```dart
+   // Before
+   final scope = Scope(null);
+   
+   // After - with local detection
+   final scope = CherryPick.openSafeRootScope();
+   
+   // Or with global detection
+   final scope = CherryPick.openGlobalSafeRootScope();
+   ```
+
+3. **Update error handling**:
+   ```dart
+   try {
+     final service = scope.resolve<MyService>();
+   } on CircularDependencyException catch (e) {
+     // Handle circular dependency errors
+     logger.error('Circular dependency detected: ${e.dependencyChain}');
+   }
+   ```
+
+4. **Configure for production**:
+   ```dart
+   void main() {
+     // Configure detection based on build mode
+     if (kDebugMode) {
+       CherryPick.enableGlobalCycleDetection();
+       CherryPick.enableGlobalCrossScopeCycleDetection();
+     }
+     
+     runApp(MyApp());
+   }
+   ```
+
+## API Reference
+
+### Scope Methods
+
+```dart
+class Scope {
+  // Local cycle detection
+  void enableCycleDetection();
+  void disableCycleDetection();
+  bool get isCycleDetectionEnabled;
+  List<String> get currentResolutionChain;
+  
+  // Global cycle detection
+  void enableGlobalCycleDetection();
+  void disableGlobalCycleDetection();
+  bool get isGlobalCycleDetectionEnabled;
+}
+```
+
+### CherryPick Helper Methods
+
+```dart
+class CherryPick {
+  // Global settings
+  static void enableGlobalCycleDetection();
+  static void disableGlobalCycleDetection();
+  static bool get isGlobalCycleDetectionEnabled;
+  
+  static void enableGlobalCrossScopeCycleDetection();
+  static void disableGlobalCrossScopeCycleDetection();
+  static bool get isGlobalCrossScopeCycleDetectionEnabled;
+  
+  // Per-scope settings
+  static void enableCycleDetectionForScope(Scope scope);
+  static void disableCycleDetectionForScope(Scope scope);
+  static void enableGlobalCycleDetectionForScope(Scope scope);
+  static void disableGlobalCycleDetectionForScope(Scope scope);
+  
+  // Safe scope creation
+  static Scope openSafeRootScope();
+  static Scope openGlobalSafeRootScope();
+  static Scope openSafeSubScope(Scope parent);
+}
+```
+
+### Exception Classes
+
+```dart
+class CircularDependencyException implements Exception {
+  final String message;
+  final List<String> dependencyChain;
+  
+  const CircularDependencyException(this.message, this.dependencyChain);
+  
+  @override
+  String toString() {
+    final chain = dependencyChain.join(' -> ');
+    return 'CircularDependencyException: $message\nDependency chain: $chain';
+  }
+}
+```
+
+## Best Practices
+
+### 1. Enable Detection During Development
+
+```dart
+void main() {
+  if (kDebugMode) {
+    CherryPick.enableGlobalCycleDetection();
+    CherryPick.enableGlobalCrossScopeCycleDetection();
+  }
+  
+  runApp(MyApp());
+}
+```
+
+### 2. Use Safe Scope Creation
+
+```dart
+// Instead of
+final scope = Scope(null);
+
+// Use
+final scope = CherryPick.openGlobalSafeRootScope();
+```
+
+### 3. Design Proper Architecture
+
+- Follow single responsibility principle
+- Use interfaces to decouple dependencies
+- Implement mediator pattern for complex interactions
+- Keep dependency flow unidirectional in scope hierarchy
+
+### 4. Handle Errors Gracefully
+
+```dart
+T resolveSafely<T>() {
+  try {
+    return scope.resolve<T>();
+  } on CircularDependencyException catch (e) {
+    logger.error('Circular dependency detected', e);
+    rethrow;
+  }
+}
+```
+
+### 5. Test Thoroughly
+
+- Write unit tests for dependency configurations
+- Use integration tests to verify complex scenarios
+- Enable detection in test environments
+- Test both positive and negative scenarios
+
+## Troubleshooting
+
+### Common Issues
+
+1. **False Positives**: If you're getting false circular dependency errors, check if you have proper async handling in your providers.
+
+2. **Performance Issues**: If global detection is too slow, consider using only local detection or disabling it in production.
+
+3. **Complex Hierarchies**: For very complex scope hierarchies, consider simplifying your architecture or using more interfaces.
+
+### Debug Tips
+
+1. **Check Resolution Chain**: Use `scope.currentResolutionChain` to see the current dependency resolution path.
+
+2. **Enable Logging**: Add logging to your providers to trace dependency resolution.
+
+3. **Simplify Dependencies**: Break complex dependencies into smaller, more manageable pieces.
+
+4. **Use Interfaces**: Abstract dependencies behind interfaces to reduce coupling.
+
+## Conclusion
+
+Circular dependency detection in CherryPick provides robust protection against infinite loops and stack overflow errors. By following the best practices and using the appropriate detection level for your use case, you can build reliable and maintainable dependency injection configurations.
+
+For more information, see the [main documentation](../README.md) and [examples](../example/).

doc/cycle_detection.ru.md

@@ -0,0 +1,572 @@
+# Обнаружение циклических зависимостей
+
+CherryPick предоставляет надежное обнаружение циклических зависимостей для предотвращения бесконечных циклов и ошибок переполнения стека в вашей настройке внедрения зависимостей.
+
+## Что такое циклические зависимости?
+
+Циклические зависимости возникают, когда два или более сервиса зависят друг от друга прямо или косвенно, создавая цикл в графе зависимостей.
+
+### Пример циклических зависимостей в рамках скоупа
+
+```dart
+class UserService {
+  final OrderService orderService;
+  UserService(this.orderService);
+}
+
+class OrderService {
+  final UserService userService;
+  OrderService(this.userService);
+}
+```
+
+### Пример циклических зависимостей между скоупами
+
+```dart
+// В родительском скоупе
+class ParentService {
+  final ChildService childService;
+  ParentService(this.childService); // Получает из дочернего скоупа
+}
+
+// В дочернем скоупе
+class ChildService {
+  final ParentService parentService;
+  ChildService(this.parentService); // Получает из родительского скоупа
+}
+```
+
+## Типы обнаружения
+
+### 🔍 Локальное обнаружение
+
+Обнаруживает циклические зависимости в рамках одного скоупа. Быстрое и эффективное.
+
+### 🌐 Глобальное обнаружение
+
+Обнаруживает циклические зависимости во всей иерархии скоупов. Более медленное, но обеспечивает полную защиту.
+
+## Использование
+
+### Локальное обнаружение
+
+```dart
+final scope = Scope(null);
+scope.enableCycleDetection(); // Включить локальное обнаружение
+
+scope.installModules([
+  Module((bind) {
+    bind<UserService>().to((scope) => UserService(scope.resolve<OrderService>()));
+    bind<OrderService>().to((scope) => OrderService(scope.resolve<UserService>()));
+  }),
+]);
+
+try {
+  final userService = scope.resolve<UserService>(); // Выбросит CircularDependencyException
+} catch (e) {
+  print(e); // CircularDependencyException: Circular dependency detected
+}
+```
+
+### Глобальное обнаружение
+
+```dart
+// Включить глобальное обнаружение для всех скоупов
+CherryPick.enableGlobalCrossScopeCycleDetection();
+
+final rootScope = CherryPick.openGlobalSafeRootScope();
+final childScope = rootScope.openSubScope();
+
+// Настроить зависимости, которые создают межскоуповые циклы
+rootScope.installModules([
+  Module((bind) {
+    bind<ParentService>().to((scope) => ParentService(childScope.resolve<ChildService>()));
+  }),
+]);
+
+childScope.installModules([
+  Module((bind) {
+    bind<ChildService>().to((scope) => ChildService(rootScope.resolve<ParentService>()));
+  }),
+]);
+
+try {
+  final parentService = rootScope.resolve<ParentService>(); // Выбросит CircularDependencyException
+} catch (e) {
+  print(e); // CircularDependencyException с детальной информацией о цепочке
+}
+```
+
+## API CherryPick Helper
+
+### Глобальные настройки
+
+```dart
+// Включить/отключить локальное обнаружение глобально
+CherryPick.enableGlobalCycleDetection();
+CherryPick.disableGlobalCycleDetection();
+
+// Включить/отключить глобальное межскоуповое обнаружение
+CherryPick.enableGlobalCrossScopeCycleDetection();
+CherryPick.disableGlobalCrossScopeCycleDetection();
+
+// Проверить текущие настройки
+bool localEnabled = CherryPick.isGlobalCycleDetectionEnabled;
+bool globalEnabled = CherryPick.isGlobalCrossScopeCycleDetectionEnabled;
+```
+
+### Настройки для конкретного скоупа
+
+```dart
+// Включить/отключить для конкретного скоупа
+CherryPick.enableCycleDetectionForScope(scope);
+CherryPick.disableCycleDetectionForScope(scope);
+
+// Включить/отключить глобальное обнаружение для конкретного скоупа
+CherryPick.enableGlobalCycleDetectionForScope(scope);
+CherryPick.disableGlobalCycleDetectionForScope(scope);
+```
+
+### Безопасное создание скоупов
+
+```dart
+// Создать скоупы с автоматически включенным обнаружением
+final safeRootScope = CherryPick.openSafeRootScope(); // Локальное обнаружение включено
+final globalSafeRootScope = CherryPick.openGlobalSafeRootScope(); // Включены локальное и глобальное
+final safeSubScope = CherryPick.openSafeSubScope(parentScope); // Наследует настройки родителя
+```
+
+## Соображения производительности
+
+| Тип обнаружения | Накладные расходы | Рекомендуемое использование |
+|-----------------|-------------------|----------------------------|
+| **Локальное** | Минимальные (~5%) | Разработка, тестирование |
+| **Глобальное** | Умеренные (~15%) | Сложные иерархии, критические функции |
+| **Отключено** | Нет | Продакшн (после тестирования) |
+
+### Рекомендации
+
+- **Разработка**: Включите локальное и глобальное обнаружение для максимальной безопасности
+- **Тестирование**: Оставьте обнаружение включенным для раннего выявления проблем
+- **Продакшн**: Рассмотрите отключение для производительности, но только после тщательного тестирования
+
+```dart
+import 'package:flutter/foundation.dart';
+
+void configureCycleDetection() {
+  if (kDebugMode) {
+    // Включить полную защиту в режиме отладки
+    CherryPick.enableGlobalCycleDetection();
+    CherryPick.enableGlobalCrossScopeCycleDetection();
+  } else {
+    // Отключить в релизном режиме для производительности
+    CherryPick.disableGlobalCycleDetection();
+    CherryPick.disableGlobalCrossScopeCycleDetection();
+  }
+}
+```
+
+## Архитектурные паттерны
+
+### Паттерн Repository
+
+```dart
+// ✅ Правильно: Repository не зависит от сервиса
+class UserRepository {
+  final ApiClient apiClient;
+  UserRepository(this.apiClient);
+}
+
+class UserService {
+  final UserRepository repository;
+  UserService(this.repository);
+}
+
+// ❌ Неправильно: Циклическая зависимость
+class UserRepository {
+  final UserService userService; // Не делайте так!
+  UserRepository(this.userService);
+}
+```
+
+### Паттерн Mediator
+
+```dart
+// ✅ Правильно: Используйте медиатор для разрыва циклов
+abstract class EventBus {
+  void publish<T>(T event);
+  Stream<T> listen<T>();
+}
+
+class UserService {
+  final EventBus eventBus;
+  UserService(this.eventBus);
+  
+  void createUser(User user) {
+    // ... логика создания пользователя
+    eventBus.publish(UserCreatedEvent(user));
+  }
+}
+
+class OrderService {
+  final EventBus eventBus;
+  OrderService(this.eventBus) {
+    eventBus.listen<UserCreatedEvent>().listen(_onUserCreated);
+  }
+  
+  void _onUserCreated(UserCreatedEvent event) {
+    // Реагировать на создание пользователя без прямой зависимости
+  }
+}
+```
+
+## Лучшие практики иерархии скоупов
+
+### Правильный поток зависимостей
+
+```dart
+// ✅ Правильно: Зависимости текут вниз по иерархии
+// Корневой скоуп: Основные сервисы
+final rootScope = CherryPick.openGlobalSafeRootScope();
+rootScope.installModules([
+  Module((bind) {
+    bind<DatabaseService>().singleton((scope) => DatabaseService());
+    bind<ApiClient>().singleton((scope) => ApiClient());
+  }),
+]);
+
+// Скоуп функции: Сервисы, специфичные для функции
+final featureScope = rootScope.openSubScope();
+featureScope.installModules([
+  Module((bind) {
+    bind<UserRepository>().to((scope) => UserRepository(scope.resolve<ApiClient>()));
+    bind<UserService>().to((scope) => UserService(scope.resolve<UserRepository>()));
+  }),
+]);
+
+// UI скоуп: Сервисы, специфичные для UI
+final uiScope = featureScope.openSubScope();
+uiScope.installModules([
+  Module((bind) {
+    bind<UserController>().to((scope) => UserController(scope.resolve<UserService>()));
+  }),
+]);
+```
+
+### Избегайте межскоуповых зависимостей
+
+```dart
+// ❌ Неправильно: Дочерний скоуп зависит от конкретных сервисов родителя
+childScope.installModules([
+  Module((bind) {
+    bind<ChildService>().to((scope) => 
+      ChildService(rootScope.resolve<ParentService>()) // Рискованно!
+    );
+  }),
+]);
+
+// ✅ Правильно: Используйте интерфейсы и правильное внедрение зависимостей
+abstract class IParentService {
+  void doSomething();
+}
+
+class ParentService implements IParentService {
+  void doSomething() { /* реализация */ }
+}
+
+// В корневом скоупе
+rootScope.installModules([
+  Module((bind) {
+    bind<IParentService>().to((scope) => ParentService());
+  }),
+]);
+
+// В дочернем скоупе - разрешение через обычную иерархию
+childScope.installModules([
+  Module((bind) {
+    bind<ChildService>().to((scope) => 
+      ChildService(scope.resolve<IParentService>()) // Безопасно!
+    );
+  }),
+]);
+```
+
+## Режим отладки
+
+### Отслеживание цепочки разрешения
+
+```dart
+// Включить режим отладки для отслеживания цепочек разрешения
+final scope = CherryPick.openGlobalSafeRootScope();
+
+// Доступ к текущей цепочке разрешения для отладки
+print('Текущая цепочка разрешения: ${scope.currentResolutionChain}');
+
+// Доступ к глобальной цепочке разрешения
+print('Глобальная цепочка разрешения: ${GlobalCycleDetector.instance.currentGlobalResolutionChain}');
+```
+
+### Детали исключений
+
+```dart
+try {
+  final service = scope.resolve<CircularService>();
+} on CircularDependencyException catch (e) {
+  print('Ошибка: ${e.message}');
+  print('Цепочка зависимостей: ${e.dependencyChain.join(' -> ')}');
+  
+  // Для глобального обнаружения доступен дополнительный контекст
+  if (e.message.contains('cross-scope')) {
+    print('Это межскоуповая циклическая зависимость');
+  }
+}
+```
+
+## Интеграция с тестированием
+
+### Модульные тесты
+
+```dart
+import 'package:test/test.dart';
+import 'package:cherrypick/cherrypick.dart';
+
+void main() {
+  group('Обнаружение циклических зависимостей', () {
+    setUp(() {
+      // Включить обнаружение для тестов
+      CherryPick.enableGlobalCycleDetection();
+      CherryPick.enableGlobalCrossScopeCycleDetection();
+    });
+    
+    tearDown(() {
+      // Очистка после тестов
+      CherryPick.disableGlobalCycleDetection();
+      CherryPick.disableGlobalCrossScopeCycleDetection();
+    });
+    
+    test('должен обнаружить циклическую зависимость', () {
+      final scope = CherryPick.openGlobalSafeRootScope();
+      
+      scope.installModules([
+        Module((bind) {
+          bind<ServiceA>().to((scope) => ServiceA(scope.resolve<ServiceB>()));
+          bind<ServiceB>().to((scope) => ServiceB(scope.resolve<ServiceA>()));
+        }),
+      ]);
+      
+      expect(
+        () => scope.resolve<ServiceA>(),
+        throwsA(isA<CircularDependencyException>()),
+      );
+    });
+  });
+}
+```
+
+### Интеграционные тесты
+
+```dart
+testWidgets('должен обрабатывать циклические зависимости в дереве виджетов', (tester) async {
+  // Включить обнаружение
+  CherryPick.enableGlobalCycleDetection();
+  
+  await tester.pumpWidget(
+    CherryPickProvider(
+      create: () {
+        final scope = CherryPick.openGlobalSafeRootScope();
+        // Настроить модули, которые могут иметь циклы
+        return scope;
+      },
+      child: MyApp(),
+    ),
+  );
+  
+  // Проверить, что циклические зависимости правильно обрабатываются
+  expect(find.text('Ошибка: Обнаружена циклическая зависимость'), findsNothing);
+});
+```
+
+## Руководство по миграции
+
+### С версии 2.1.x на 2.2.x
+
+1. **Обновите зависимости**:
+   ```yaml
+   dependencies:
+     cherrypick: ^2.2.0
+   ```
+
+2. **Включите обнаружение в существующем коде**:
+   ```dart
+   // Раньше
+   final scope = Scope(null);
+   
+   // Теперь - с локальным обнаружением
+   final scope = CherryPick.openSafeRootScope();
+   
+   // Или с глобальным обнаружением
+   final scope = CherryPick.openGlobalSafeRootScope();
+   ```
+
+3. **Обновите обработку ошибок**:
+   ```dart
+   try {
+     final service = scope.resolve<MyService>();
+   } on CircularDependencyException catch (e) {
+     // Обработать ошибки циклических зависимостей
+     logger.error('Обнаружена циклическая зависимость: ${e.dependencyChain}');
+   }
+   ```
+
+4. **Настройте для продакшна**:
+   ```dart
+   void main() {
+     // Настроить обнаружение в зависимости от режима сборки
+     if (kDebugMode) {
+       CherryPick.enableGlobalCycleDetection();
+       CherryPick.enableGlobalCrossScopeCycleDetection();
+     }
+     
+     runApp(MyApp());
+   }
+   ```
+
+## Справочник API
+
+### Методы Scope
+
+```dart
+class Scope {
+  // Локальное обнаружение циклов
+  void enableCycleDetection();
+  void disableCycleDetection();
+  bool get isCycleDetectionEnabled;
+  List<String> get currentResolutionChain;
+  
+  // Глобальное обнаружение циклов
+  void enableGlobalCycleDetection();
+  void disableGlobalCycleDetection();
+  bool get isGlobalCycleDetectionEnabled;
+}
+```
+
+### Методы CherryPick Helper
+
+```dart
+class CherryPick {
+  // Глобальные настройки
+  static void enableGlobalCycleDetection();
+  static void disableGlobalCycleDetection();
+  static bool get isGlobalCycleDetectionEnabled;
+  
+  static void enableGlobalCrossScopeCycleDetection();
+  static void disableGlobalCrossScopeCycleDetection();
+  static bool get isGlobalCrossScopeCycleDetectionEnabled;
+  
+  // Настройки для конкретного скоупа
+  static void enableCycleDetectionForScope(Scope scope);
+  static void disableCycleDetectionForScope(Scope scope);
+  static void enableGlobalCycleDetectionForScope(Scope scope);
+  static void disableGlobalCycleDetectionForScope(Scope scope);
+  
+  // Безопасное создание скоупов
+  static Scope openSafeRootScope();
+  static Scope openGlobalSafeRootScope();
+  static Scope openSafeSubScope(Scope parent);
+}
+```
+
+### Классы исключений
+
+```dart
+class CircularDependencyException implements Exception {
+  final String message;
+  final List<String> dependencyChain;
+  
+  const CircularDependencyException(this.message, this.dependencyChain);
+  
+  @override
+  String toString() {
+    final chain = dependencyChain.join(' -> ');
+    return 'CircularDependencyException: $message\nЦепочка зависимостей: $chain';
+  }
+}
+```
+
+## Лучшие практики
+
+### 1. Включайте обнаружение во время разработки
+
+```dart
+void main() {
+  if (kDebugMode) {
+    CherryPick.enableGlobalCycleDetection();
+    CherryPick.enableGlobalCrossScopeCycleDetection();
+  }
+  
+  runApp(MyApp());
+}
+```
+
+### 2. Используйте безопасное создание скоупов
+
+```dart
+// Вместо
+final scope = Scope(null);
+
+// Используйте
+final scope = CherryPick.openGlobalSafeRootScope();
+```
+
+### 3. Проектируйте правильную архитектуру
+
+- Следуйте принципу единственной ответственности
+- Используйте интерфейсы для разделения зависимостей
+- Реализуйте паттерн медиатор для сложных взаимодействий
+- Поддерживайте однонаправленный поток зависимостей в иерархии скоупов
+
+### 4. Обрабатывайте ошибки корректно
+
+```dart
+T resolveSafely<T>() {
+  try {
+    return scope.resolve<T>();
+  } on CircularDependencyException catch (e) {
+    logger.error('Обнаружена циклическая зависимость', e);
+    rethrow;
+  }
+}
+```
+
+### 5. Тестируйте тщательно
+
+- Пишите модульные тесты для конфигураций зависимостей
+- Используйте интеграционные тесты для проверки сложных сценариев
+- Включайте обнаружение в тестовых средах
+- Тестируйте как положительные, так и отрицательные сценарии
+
+## Устранение неполадок
+
+### Распространенные проблемы
+
+1. **Ложные срабатывания**: Если вы получаете ложные ошибки циклических зависимостей, проверьте правильность обработки async в ваших провайдерах.
+
+2. **Проблемы производительности**: Если глобальное обнаружение слишком медленное, рассмотрите использование только локального обнаружения или отключение в продакшне.
+
+3. **Сложные иерархии**: Для очень сложных иерархий скоупов рассмотрите упрощение архитектуры или использование большего количества интерфейсов.
+
+### Советы по отладке
+
+1. **Проверьте цепочку разрешения**: Используйте `scope.currentResolutionChain` для просмотра текущего пути разрешения зависимостей.
+
+2. **Включите логирование**: Добавьте логирование в ваши провайдеры для трассировки разрешения зависимостей.
+
+3. **Упростите зависимости**: Разбейте сложные зависимости на более мелкие, управляемые части.
+
+4. **Используйте интерфейсы**: Абстрагируйте зависимости за интерфейсами для уменьшения связанности.
+
+## Заключение
+
+Обнаружение циклических зависимостей в CherryPick обеспечивает надежную защиту от бесконечных циклов и ошибок переполнения стека. Следуя лучшим практикам и используя подходящий уровень обнаружения для вашего случая использования, вы можете создавать надежные и поддерживаемые конфигурации внедрения зависимостей.
+
+Для получения дополнительной информации см. [основную документацию](../README.md) и [примеры](../example/).

examples/client_app/pubspec.lock

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

examples/postly/lib/main.dart

@@ -1,9 +1,17 @@
 import 'package:cherrypick/cherrypick.dart';
+import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:postly/app.dart';
 import 'di/app_module.dart';
 
 void main() {
+  // Включаем cycle-detection только в debug/test
+  if (kDebugMode) {
+    CherryPick.enableGlobalCycleDetection();
+    CherryPick.enableGlobalCrossScopeCycleDetection();
+  }
+
+  // Используем safe root scope для гарантии защиты
   CherryPick.openRootScope().installModules([$AppModule()]);
   runApp(MyApp());
 }

examples/postly/pubspec.lock

@@ -151,21 +151,21 @@ packages:
       path: "../../cherrypick"
       relative: true
     source: path
-    version: "2.2.0-dev.1"
+    version: "2.2.0"
   cherrypick_annotations:
     dependency: "direct main"
     description:
       path: "../../cherrypick_annotations"
       relative: true
     source: path
-    version: "1.1.0-dev.1"
+    version: "1.1.0"
   cherrypick_generator:
     dependency: "direct dev"
     description:
       path: "../../cherrypick_generator"
       relative: true
     source: path
-    version: "1.1.0-dev.5"
+    version: "1.1.0"
   clock:
     dependency: transitive
     description: