dartmind 17.0.0

package/dist/__tests__/hybrid-pattern-resolver.test.js

@@ -0,0 +1,713 @@
+/**
+ * DartMind V17 - Hybrid Pattern Resolver Tests
+ * Day 7: Tests for PatternDetector, LegacyProtector, and HybridPatternResolver
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createPatternDetector, createLegacyProtector, createHybridPatternResolver, confidenceToLevel, arePatternsCompatible, getPatternFamily, } from '../indexer/index.js';
+// ============================================================================
+// Test Fixtures
+// ============================================================================
+const createBlocFile = () => ({
+    path: '/project/lib/features/counter/bloc/counter_bloc.dart',
+    content: `
+import 'package:flutter_bloc/flutter_bloc.dart';
+
+part 'counter_event.dart';
+part 'counter_state.dart';
+
+class CounterBloc extends Bloc<CounterEvent, CounterState> {
+  CounterBloc() : super(CounterInitial()) {
+    on<CounterIncremented>(_onIncrement);
+    on<CounterDecremented>(_onDecrement);
+  }
+
+  void _onIncrement(CounterIncremented event, Emitter<CounterState> emit) {
+    emit(CounterState(count: state.count + 1));
+  }
+
+  void _onDecrement(CounterDecremented event, Emitter<CounterState> emit) {
+    emit(CounterState(count: state.count - 1));
+  }
+}
+`,
+});
+const createProviderFile = () => ({
+    path: '/project/lib/providers/counter_provider.dart',
+    content: `
+import 'package:provider/provider.dart';
+import 'package:flutter/foundation.dart';
+
+class CounterProvider extends ChangeNotifier {
+  int _count = 0;
+
+  int get count => _count;
+
+  void increment() {
+    _count++;
+    notifyListeners();
+  }
+
+  void decrement() {
+    _count--;
+    notifyListeners();
+  }
+}
+`,
+});
+const createRiverpodFile = () => ({
+    path: '/project/lib/providers/counter_riverpod.dart',
+    content: `
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+@riverpod
+class Counter extends _$Counter {
+  @override
+  int build() => 0;
+
+  void increment() => state++;
+  void decrement() => state--;
+}
+
+final counterProvider = StateNotifierProvider<CounterNotifier, int>((ref) {
+  return CounterNotifier();
+});
+`,
+});
+const createGetxFile = () => ({
+    path: '/project/lib/controllers/counter_controller.dart',
+    content: `
+import 'package:get/get.dart';
+
+class CounterController extends GetxController {
+  var count = 0.obs;
+
+  void increment() => count++;
+  void decrement() => count--;
+}
+`,
+});
+const createLegacyFile = () => ({
+    path: '/project/lib/legacy/old_counter.dart',
+    content: `
+// LEGACY: This code is deprecated and will be removed
+// TODO: legacy - migrate to BLoC
+
+@deprecated
+class OldCounter {
+  int _count = 0;
+
+  int get count => _count;
+
+  void increment() {
+    _count++;
+  }
+}
+`,
+});
+const createCleanArchitectureFiles = () => [
+    {
+        path: '/project/lib/domain/entities/user.dart',
+        content: `
+class User {
+  final String id;
+  final String name;
+  User({required this.id, required this.name});
+}
+`,
+    },
+    {
+        path: '/project/lib/domain/usecases/get_user.dart',
+        content: `
+import '../entities/user.dart';
+import '../repositories/user_repository.dart';
+
+class GetUser {
+  final UserRepository repository;
+  GetUser(this.repository);
+
+  Future<User?> call(String id) => repository.getUser(id);
+}
+`,
+    },
+    {
+        path: '/project/lib/data/repositories/user_repository_impl.dart',
+        content: `
+import '../../domain/entities/user.dart';
+import '../../domain/repositories/user_repository.dart';
+
+class UserRepositoryImpl implements UserRepository {
+  @override
+  Future<User?> getUser(String id) async {
+    // Implementation
+    return null;
+  }
+}
+`,
+    },
+    {
+        path: '/project/lib/presentation/pages/user_page.dart',
+        content: `
+import 'package:flutter/material.dart';
+
+class UserPage extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: Center(child: Text('User Page')),
+    );
+  }
+}
+`,
+    },
+];
+// ============================================================================
+// PatternTypes Utility Tests
+// ============================================================================
+describe('PatternTypes utilities', () => {
+    describe('confidenceToLevel', () => {
+        it('should return high for confidence >= 0.8', () => {
+            expect(confidenceToLevel(0.8)).toBe('high');
+            expect(confidenceToLevel(0.9)).toBe('high');
+            expect(confidenceToLevel(1.0)).toBe('high');
+        });
+        it('should return medium for confidence >= 0.5 and < 0.8', () => {
+            expect(confidenceToLevel(0.5)).toBe('medium');
+            expect(confidenceToLevel(0.7)).toBe('medium');
+            expect(confidenceToLevel(0.79)).toBe('medium');
+        });
+        it('should return low for confidence >= 0.3 and < 0.5', () => {
+            expect(confidenceToLevel(0.3)).toBe('low');
+            expect(confidenceToLevel(0.4)).toBe('low');
+            expect(confidenceToLevel(0.49)).toBe('low');
+        });
+        it('should return uncertain for confidence < 0.3', () => {
+            expect(confidenceToLevel(0.0)).toBe('uncertain');
+            expect(confidenceToLevel(0.1)).toBe('uncertain');
+            expect(confidenceToLevel(0.29)).toBe('uncertain');
+        });
+    });
+    describe('arePatternsCompatible', () => {
+        it('should return true for same pattern', () => {
+            expect(arePatternsCompatible('bloc', 'bloc')).toBe(true);
+            expect(arePatternsCompatible('riverpod', 'riverpod')).toBe(true);
+        });
+        it('should return false for incompatible patterns', () => {
+            expect(arePatternsCompatible('bloc', 'getx')).toBe(false);
+            expect(arePatternsCompatible('riverpod', 'provider')).toBe(false);
+            expect(arePatternsCompatible('riverpod', 'getx')).toBe(false);
+            expect(arePatternsCompatible('redux', 'mobx')).toBe(false);
+        });
+        it('should return true for compatible patterns', () => {
+            expect(arePatternsCompatible('bloc', 'repository')).toBe(true);
+            expect(arePatternsCompatible('riverpod', 'clean')).toBe(true);
+            expect(arePatternsCompatible('mvc', 'singleton')).toBe(true);
+        });
+    });
+    describe('getPatternFamily', () => {
+        it('should return state-management for state management patterns', () => {
+            expect(getPatternFamily('bloc')).toBe('state-management');
+            expect(getPatternFamily('cubit')).toBe('state-management');
+            expect(getPatternFamily('provider')).toBe('state-management');
+            expect(getPatternFamily('riverpod')).toBe('state-management');
+            expect(getPatternFamily('getx')).toBe('state-management');
+            expect(getPatternFamily('redux')).toBe('state-management');
+            expect(getPatternFamily('mobx')).toBe('state-management');
+        });
+        it('should return architecture for architecture patterns', () => {
+            expect(getPatternFamily('mvc')).toBe('architecture');
+            expect(getPatternFamily('mvvm')).toBe('architecture');
+            expect(getPatternFamily('clean')).toBe('architecture');
+            expect(getPatternFamily('stacked')).toBe('architecture');
+        });
+        it('should return design for design patterns', () => {
+            expect(getPatternFamily('repository')).toBe('design');
+            expect(getPatternFamily('singleton')).toBe('design');
+            expect(getPatternFamily('factory')).toBe('design');
+            expect(getPatternFamily('observer')).toBe('design');
+        });
+        it('should return unknown for unknown pattern', () => {
+            expect(getPatternFamily('unknown')).toBe('unknown');
+        });
+    });
+});
+// ============================================================================
+// PatternDetector Tests
+// ============================================================================
+describe('PatternDetector', () => {
+    let detector;
+    beforeEach(() => {
+        detector = createPatternDetector();
+    });
+    describe('analyzeModule', () => {
+        it('should detect BLoC pattern', async () => {
+            const files = [createBlocFile()];
+            const analysis = await detector.analyzeModule('/project/lib/features/counter', files);
+            expect(analysis.primaryPattern).not.toBeNull();
+            expect(analysis.primaryPattern?.pattern).toBe('bloc');
+            expect(analysis.primaryPattern?.confidence).toBeGreaterThan(0);
+        });
+        it('should detect Provider pattern', async () => {
+            const files = [createProviderFile()];
+            const analysis = await detector.analyzeModule('/project/lib/providers', files);
+            expect(analysis.primaryPattern).not.toBeNull();
+            expect(analysis.primaryPattern?.pattern).toBe('provider');
+        });
+        it('should detect Riverpod pattern', async () => {
+            const files = [createRiverpodFile()];
+            const analysis = await detector.analyzeModule('/project/lib/providers', files);
+            expect(analysis.primaryPattern).not.toBeNull();
+            expect(analysis.primaryPattern?.pattern).toBe('riverpod');
+        });
+        it('should detect GetX pattern', async () => {
+            const files = [createGetxFile()];
+            const analysis = await detector.analyzeModule('/project/lib/controllers', files);
+            expect(analysis.primaryPattern).not.toBeNull();
+            expect(analysis.primaryPattern?.pattern).toBe('getx');
+        });
+        it('should detect Clean Architecture pattern', async () => {
+            const files = createCleanArchitectureFiles();
+            const analysis = await detector.analyzeModule('/project/lib', files);
+            expect(analysis.allPatterns.some((p) => p.pattern === 'clean')).toBe(true);
+        });
+        it('should detect legacy markers', async () => {
+            const files = [createLegacyFile()];
+            const analysis = await detector.analyzeModule('/project/lib/legacy', files);
+            expect(analysis.isLegacy).toBe(true);
+            expect(analysis.legacyMarkers.length).toBeGreaterThan(0);
+        });
+        it('should track files analyzed count', async () => {
+            const files = [createBlocFile(), createProviderFile()];
+            const analysis = await detector.analyzeModule('/project/lib', files);
+            expect(analysis.filesAnalyzed).toBe(2);
+        });
+        it('should emit progress events', async () => {
+            const events = [];
+            detector.onPatternEvent((event) => events.push(event.type));
+            const files = [createBlocFile()];
+            await detector.analyzeModule('/project/lib', files);
+            expect(events).toContain('detection:started');
+            expect(events).toContain('detection:completed');
+        });
+    });
+    describe('configuration', () => {
+        it('should respect minConfidence setting', async () => {
+            const strictDetector = createPatternDetector({ minConfidence: 0.9 });
+            const files = [createBlocFile()];
+            const analysis = await strictDetector.analyzeModule('/project/lib', files);
+            // High confidence patterns should still be detected
+            if (analysis.primaryPattern) {
+                expect(analysis.primaryPattern.confidence).toBeGreaterThanOrEqual(0.9);
+            }
+        });
+        it('should exclude patterns based on config', async () => {
+            const limitedDetector = createPatternDetector({
+                excludedPatterns: ['bloc'],
+            });
+            const files = [createBlocFile()];
+            const analysis = await limitedDetector.analyzeModule('/project/lib', files);
+            expect(analysis.allPatterns.every((p) => p.pattern !== 'bloc')).toBe(true);
+        });
+        it('should exclude files based on config', async () => {
+            const limitedDetector = createPatternDetector({
+                excludeFiles: ['**/*_bloc.dart'],
+            });
+            const files = [createBlocFile()];
+            const analysis = await limitedDetector.analyzeModule('/project/lib', files);
+            expect(analysis.filesAnalyzed).toBe(0);
+        });
+    });
+});
+// ============================================================================
+// LegacyProtector Tests
+// ============================================================================
+describe('LegacyProtector', () => {
+    let protector;
+    beforeEach(() => {
+        protector = createLegacyProtector();
+    });
+    afterEach(() => {
+        protector.clear();
+    });
+    describe('evaluateModule', () => {
+        it('should protect modules in legacy directories', () => {
+            const analysis = {
+                modulePath: '/project/lib/legacy/old_feature',
+                moduleName: 'old_feature',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: false,
+                legacyMarkers: [],
+                filesAnalyzed: 0,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            const status = protector.evaluateModule(analysis);
+            expect(status.isProtected).toBe(true);
+            expect(status.level).toBe('full');
+        });
+        it('should not protect test directories', () => {
+            const analysis = {
+                modulePath: '/project/lib/test/legacy',
+                moduleName: 'legacy',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'legacy-comment',
+                        description: 'Legacy code',
+                        filePath: '/project/lib/test/legacy/old.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            const status = protector.evaluateModule(analysis);
+            expect(status.isProtected).toBe(false);
+        });
+        it('should auto-protect modules with legacy markers', () => {
+            const analysis = {
+                modulePath: '/project/lib/feature',
+                moduleName: 'feature',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'deprecated-annotation',
+                        description: '@deprecated annotation found',
+                        filePath: '/project/lib/feature/old.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            const status = protector.evaluateModule(analysis);
+            expect(status.isProtected).toBe(true);
+            expect(status.level).toBe('partial');
+        });
+    });
+    describe('protectModule', () => {
+        it('should store protection record', () => {
+            const analysis = {
+                modulePath: '/project/lib/legacy/old',
+                moduleName: 'old',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'legacy-directory',
+                        description: 'In legacy directory',
+                        filePath: '/project/lib/legacy/old/file.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            const record = protector.protectModule(analysis);
+            expect(record.modulePath).toBe('/project/lib/legacy/old');
+            expect(record.status.isProtected).toBe(true);
+            expect(protector.getProtectionRecord('/project/lib/legacy/old')).toBeDefined();
+        });
+        it('should support manual override', () => {
+            const analysis = {
+                modulePath: '/project/lib/feature',
+                moduleName: 'feature',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: false,
+                legacyMarkers: [],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            const record = protector.protectModule(analysis, {
+                isProtected: true,
+                level: 'full',
+                restrictions: ['read-only'],
+                reason: 'Manual protection',
+            });
+            expect(record.status.isProtected).toBe(true);
+            expect(record.status.level).toBe('full');
+            expect(record.protectedBy).toBe('manual');
+        });
+    });
+    describe('checkOperation', () => {
+        it('should allow operations on unprotected modules', () => {
+            const result = protector.checkOperation('/project/lib/feature', 'refactor');
+            expect(result.allowed).toBe(true);
+        });
+        it('should block restricted operations on protected modules', () => {
+            const analysis = {
+                modulePath: '/project/lib/legacy/old',
+                moduleName: 'old',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'legacy-directory',
+                        description: 'In legacy directory',
+                        filePath: '/project/lib/legacy/old/file.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            protector.protectModule(analysis);
+            const result = protector.checkOperation('/project/lib/legacy/old', 'refactor');
+            expect(result.allowed).toBe(false);
+            expect(result.reason).toContain('no-refactor');
+        });
+        it('should warn but allow with warn-only restriction', () => {
+            const analysis = {
+                modulePath: '/project/lib/feature',
+                moduleName: 'feature',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'legacy-comment',
+                        description: 'Legacy code',
+                        filePath: '/project/lib/feature/old.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            protector.protectModule(analysis);
+            const result = protector.checkOperation('/project/lib/feature', 'refactor');
+            // With default config, partial protection includes warn-only
+            expect(result.allowed).toBe(true);
+            expect(result.warning).toBeDefined();
+        });
+    });
+    describe('isFileProtected', () => {
+        it('should return true for files in protected modules', () => {
+            const analysis = {
+                modulePath: '/project/lib/legacy',
+                moduleName: 'legacy',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'legacy-directory',
+                        description: 'Legacy directory',
+                        filePath: '/project/lib/legacy/file.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            protector.protectModule(analysis);
+            expect(protector.isFileProtected('/project/lib/legacy/subfolder/file.dart')).toBe(true);
+            expect(protector.isFileProtected('/project/lib/feature/file.dart')).toBe(false);
+        });
+    });
+    describe('getStats', () => {
+        it('should return correct statistics', () => {
+            const analysis1 = {
+                modulePath: '/project/lib/legacy/old1',
+                moduleName: 'old1',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'legacy-directory',
+                        description: 'Legacy',
+                        filePath: '/project/lib/legacy/old1/file.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            const analysis2 = {
+                modulePath: '/project/lib/legacy/old2',
+                moduleName: 'old2',
+                primaryPattern: null,
+                secondaryPatterns: [],
+                allPatterns: [],
+                isMixedPattern: false,
+                isLegacy: true,
+                legacyMarkers: [
+                    {
+                        type: 'deprecated-annotation',
+                        description: 'Deprecated',
+                        filePath: '/project/lib/legacy/old2/file.dart',
+                    },
+                ],
+                filesAnalyzed: 1,
+                symbolsAnalyzed: 0,
+                analyzedAt: Date.now(),
+            };
+            protector.protectModule(analysis1);
+            protector.protectModule(analysis2);
+            const stats = protector.getStats();
+            expect(stats.totalProtected).toBe(2);
+            expect(stats.totalMarkers).toBe(2);
+            expect(stats.byProtector.auto).toBe(2);
+        });
+    });
+});
+// ============================================================================
+// HybridPatternResolver Tests
+// ============================================================================
+describe('HybridPatternResolver', () => {
+    let resolver;
+    beforeEach(() => {
+        resolver = createHybridPatternResolver();
+    });
+    afterEach(() => {
+        resolver.dispose();
+    });
+    describe('analyzeModule', () => {
+        it('should detect patterns and apply protection', async () => {
+            const files = [createLegacyFile()];
+            const analysis = await resolver.analyzeModule('/project/lib/legacy', files);
+            expect(analysis.isLegacy).toBe(true);
+            expect(resolver.isFileProtected('/project/lib/legacy/file.dart')).toBe(true);
+        });
+        it('should cache analysis results', async () => {
+            const files = [createBlocFile()];
+            const analysis1 = await resolver.analyzeModule('/project/lib/bloc', files);
+            const analysis2 = await resolver.analyzeModule('/project/lib/bloc', files);
+            // Should return same cached result
+            expect(analysis1.analyzedAt).toBe(analysis2.analyzedAt);
+        });
+        it('should skip cache when requested', async () => {
+            const files = [createBlocFile()];
+            const analysis1 = await resolver.analyzeModule('/project/lib/bloc', files);
+            // Small delay to ensure different timestamp
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            const analysis2 = await resolver.analyzeModule('/project/lib/bloc', files, {
+                skipCache: true,
+            });
+            expect(analysis2.analyzedAt).toBeGreaterThan(analysis1.analyzedAt);
+        });
+    });
+    describe('analyzeProject', () => {
+        it('should analyze multiple modules', async () => {
+            const moduleFiles = new Map();
+            moduleFiles.set('/project/lib/bloc', [createBlocFile()]);
+            moduleFiles.set('/project/lib/provider', [createProviderFile()]);
+            const result = await resolver.analyzeProject('/project', moduleFiles);
+            expect(result.modules.length).toBe(2);
+            expect(result.stats.totalModules).toBe(2);
+        });
+        it('should calculate project statistics', async () => {
+            const moduleFiles = new Map();
+            moduleFiles.set('/project/lib/bloc', [createBlocFile()]);
+            moduleFiles.set('/project/lib/legacy', [createLegacyFile()]);
+            const result = await resolver.analyzeProject('/project', moduleFiles);
+            expect(result.stats.legacyModules).toBe(1);
+            expect(result.stats.patternDistribution.size).toBeGreaterThan(0);
+        });
+        it('should detect pattern conflicts', async () => {
+            // Create modules with incompatible patterns in same parent
+            const blocFile = {
+                path: '/project/lib/features/bloc_feature.dart',
+                content: `
+import 'package:flutter_bloc/flutter_bloc.dart';
+class MyBloc extends Bloc<Event, State> {}
+`,
+            };
+            const getxFile = {
+                path: '/project/lib/features/getx_feature.dart',
+                content: `
+import 'package:get/get.dart';
+class MyController extends GetxController {}
+`,
+            };
+            const moduleFiles = new Map();
+            moduleFiles.set('/project/lib/features/bloc', [blocFile]);
+            moduleFiles.set('/project/lib/features/getx', [getxFile]);
+            const result = await resolver.analyzeProject('/project', moduleFiles);
+            // Conflicts may or may not be detected depending on confidence levels
+            // The important thing is that the analysis completes
+            expect(result.analyzedAt).toBeDefined();
+        });
+    });
+    describe('checkOperation', () => {
+        it('should delegate to protector', async () => {
+            const files = [createLegacyFile()];
+            await resolver.analyzeModule('/project/lib/legacy', files);
+            const result = resolver.checkOperation('/project/lib/legacy', 'refactor');
+            expect(result.protectionStatus).toBeDefined();
+        });
+    });
+    describe('comparePatterns', () => {
+        it('should return compatibility info for patterns', () => {
+            const comparison = resolver.comparePatterns('bloc', 'getx');
+            expect(comparison.canCoexist).toBe(false);
+            expect(comparison.migrationDifficulty).toBe('not-recommended');
+        });
+        it('should indicate same patterns are easy', () => {
+            const comparison = resolver.comparePatterns('bloc', 'bloc');
+            expect(comparison.canCoexist).toBe(true);
+            expect(comparison.migrationDifficulty).toBe('easy');
+        });
+    });
+    describe('evolution tracking', () => {
+        it('should track pattern evolution', async () => {
+            const resolverWithTracking = createHybridPatternResolver({
+                trackEvolution: true,
+            });
+            const files = [createBlocFile()];
+            await resolverWithTracking.analyzeModule('/project/lib/bloc', files, { skipCache: true });
+            const history = resolverWithTracking.getEvolutionHistory('/project/lib/bloc');
+            expect(history.length).toBe(1);
+            expect(history[0].currentPattern).toBe('bloc');
+            resolverWithTracking.dispose();
+        });
+    });
+    describe('event handling', () => {
+        it('should forward events from detector and protector', async () => {
+            const events = [];
+            resolver.onPatternEvent((event) => events.push(event.type));
+            const files = [createLegacyFile()];
+            await resolver.analyzeModule('/project/lib/legacy', files);
+            expect(events).toContain('detection:started');
+            expect(events).toContain('detection:completed');
+            expect(events).toContain('legacy:marker-found');
+        });
+    });
+    describe('dispose', () => {
+        it('should clear all caches and state', async () => {
+            const files = [createBlocFile()];
+            await resolver.analyzeModule('/project/lib/bloc', files);
+            resolver.dispose();
+            expect(resolver.getModulePattern('/project/lib/bloc')).toBeNull();
+            expect(resolver.getProtectionStats().totalProtected).toBe(0);
+        });
+    });
+});
+//# sourceMappingURL=hybrid-pattern-resolver.test.js.map