ultracode 5.3.0 → 5.5.0

package/dist/chunks/chaos-W3XRVJ7K.js

@@ -0,0 +1,1564 @@
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+
+// src/analysis/chaos/angular-patterns.ts
+function isStateIdentifier(name) {
+  const lowerName = name.toLowerCase();
+  const stateKeywords = [
+    "state",
+    "config",
+    "context",
+    "data",
+    "token",
+    "user",
+    "auth",
+    "session",
+    "settings",
+    "cache",
+    "store",
+    "value",
+    "status",
+    "flag",
+    "id"
+  ];
+  if (stateKeywords.some((keyword) => lowerName.includes(keyword))) {
+    return true;
+  }
+  const patterns = [
+    /^_[a-z]+$/,
+    // _token
+    /^is[A-Z]/,
+    // isLoading
+    /^has[A-Z]/,
+    // hasToken
+    /[Ss]tate$/,
+    // userState
+    /[Cc]onfig$/,
+    // apiConfig
+    /Subject$/
+    // userSubject
+  ];
+  return patterns.some((pattern) => pattern.test(name));
+}
+
+// src/analysis/chaos/chaos-analyzer.ts
+init_logging();
+
+// src/analysis/chaos/csharp-patterns.ts
+var CSHARP_ASYNC_APIS = [
+  "Task.Run",
+  "Task.Factory.StartNew",
+  "Task.WhenAll",
+  "Task.WhenAny",
+  "Task.Delay",
+  "Parallel.ForEach",
+  "Parallel.For",
+  "Parallel.ForEachAsync",
+  "ThreadPool.QueueUserWorkItem",
+  "Channel<",
+  "Channel.CreateBounded",
+  "Channel.CreateUnbounded",
+  "Timer",
+  "PeriodicTimer",
+  "BackgroundService",
+  "IHostedService"
+];
+var CSHARP_LOCK_PATTERNS = [
+  /\block\s*\(/,
+  /SemaphoreSlim/,
+  /Monitor\.(Enter|Exit|TryEnter)/,
+  /Interlocked\./,
+  /ReaderWriterLockSlim/,
+  /SpinLock/,
+  /Volatile\.(Read|Write)/,
+  /Mutex/,
+  /ConcurrentDictionary/,
+  /ConcurrentBag/,
+  /ConcurrentQueue/,
+  /ConcurrentStack/,
+  /ImmutableArray/,
+  /ImmutableList/,
+  /ImmutableDictionary/
+];
+function isCSharpStateIdentifier(entity) {
+  const name = entity.name.toLowerCase();
+  const modifiers = entity.metadata?.modifiers || [];
+  if (modifiers.includes("readonly")) {
+    return false;
+  }
+  const diServicePatterns = [
+    /^_log(ger)?$/i,
+    /^_(http)?client$/i,
+    /^_mediator$/i,
+    /^_mapper$/i,
+    /^_sender$/i,
+    /^_(message|event)?bus$/i,
+    /^_publisher$/i,
+    /^_inner$/i,
+    /^_next$/i,
+    /^_handler$/i,
+    /^_service$/i,
+    /^_provider$/i,
+    /^_factory$/i,
+    /^_repository$/i,
+    /^_config(uration)?$/i,
+    /^_options$/i,
+    /^_settings$/i,
+    /^_env(ironment)?$/i
+  ];
+  if (diServicePatterns.some((p) => p.test(entity.name))) {
+    return false;
+  }
+  if (modifiers.includes("static") && !modifiers.includes("const")) {
+    return true;
+  }
+  const stateKeywords = ["state", "cache", "connection", "session", "current", "singleton", "shared", "global"];
+  if (stateKeywords.some((kw) => name.includes(kw))) {
+    return true;
+  }
+  const weakStateKeywords = ["config", "configuration", "settings", "options", "context", "token", "instance"];
+  if (weakStateKeywords.some((kw) => name.includes(kw)) && !/^_[a-z]/.test(entity.name)) {
+    return true;
+  }
+  const typeStr = entity.type;
+  if (/^_[a-z]/.test(entity.name) && (entity.type === "variable" /* VARIABLE */ || entity.type === "constant" /* CONSTANT */ || typeStr === "field" || typeStr === "property")) {
+    return true;
+  }
+  if (/^(Is|Has|Can|Should|Current|Last|Previous)/.test(entity.name)) {
+    return true;
+  }
+  return false;
+}
+function detectCSharpChaosPatterns(entities) {
+  const patterns = [];
+  const classesByFile = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    if (entity.language !== "csharp" && entity.metadata?.language !== "csharp") {
+      continue;
+    }
+    const modifiers = entity.metadata?.modifiers || [];
+    const returnType = entity.metadata?.returnType || "";
+    const params = entity.metadata?.parameters || [];
+    const line = entity.location?.start?.line || 0;
+    const typeStr = entity.type;
+    const isFieldLike = entity.type === "variable" /* VARIABLE */ || entity.type === "constant" /* CONSTANT */ || typeStr === "field" || typeStr === "property";
+    const isMethodLike = entity.type === "method" /* METHOD */ || entity.type === "function" /* FUNCTION */ || typeStr === "constructor";
+    if (isFieldLike && modifiers.includes("static") && !modifiers.includes("readonly") && !modifiers.includes("const")) {
+      patterns.push({
+        pattern: "mutable-static",
+        severity: "critical",
+        entityId: entity.id,
+        entityName: entity.name,
+        filePath: entity.filePath,
+        line,
+        description: `Mutable static field '${entity.name}' \u2014 shared across all threads without protection`,
+        suggestion: "Use ConcurrentDictionary, add readonly, or move state to DI-managed service"
+      });
+    }
+    if (isMethodLike && modifiers.includes("async") && (returnType === "void" || returnType === "Void")) {
+      patterns.push({
+        pattern: "async-void",
+        severity: "high",
+        entityId: entity.id,
+        entityName: entity.name,
+        filePath: entity.filePath,
+        line,
+        description: `async void method '${entity.name}' \u2014 exceptions will crash the process`,
+        suggestion: "Replace 'async void' with 'async Task'. Only use async void for event handlers"
+      });
+    }
+    if (entity.type === "class" /* CLASS */) {
+      const fileClasses = classesByFile.get(entity.filePath) || [];
+      fileClasses.push(entity);
+      classesByFile.set(entity.filePath, fileClasses);
+    }
+    if (isMethodLike && (entity.name === ".ctor" || typeStr === "constructor") && params.length >= 10) {
+      patterns.push({
+        pattern: "god-service",
+        severity: "medium",
+        entityId: entity.id,
+        entityName: entity.name,
+        filePath: entity.filePath,
+        line,
+        description: `Constructor with ${params.length} parameters \u2014 likely a God Service violating SRP`,
+        suggestion: "Split into smaller focused services. Group related dependencies into aggregate services"
+      });
+    }
+    if (isMethodLike && modifiers.includes("async") && returnType !== "void" && returnType !== "Void" && (returnType.includes("Task") || returnType.includes("ValueTask")) && !params.some((p) => p.type?.includes("CancellationToken"))) {
+      patterns.push({
+        pattern: "missing-cancellation",
+        severity: "medium",
+        entityId: entity.id,
+        entityName: entity.name,
+        filePath: entity.filePath,
+        line,
+        description: `Async method '${entity.name}' without CancellationToken \u2014 cannot be cancelled gracefully`,
+        suggestion: "Add CancellationToken parameter and pass it to downstream async calls"
+      });
+    }
+    if (isFieldLike && modifiers.includes("static") && !modifiers.includes("readonly") && !modifiers.includes("const")) {
+      const decorators = entity.metadata?.decorators || [];
+      const hasSingletonIndicator = decorators.some(
+        (d) => d.name === "Singleton" || d.name === "SingleInstance" || d.name === "ServiceLifetime.Singleton"
+      ) || entity.name.toLowerCase().includes("singleton");
+      if (hasSingletonIndicator) {
+        patterns.push({
+          pattern: "singleton-mutable-state",
+          severity: "high",
+          entityId: entity.id,
+          entityName: entity.name,
+          filePath: entity.filePath,
+          line,
+          description: `Singleton class has mutable field '${entity.name}' \u2014 concurrent access will cause data races`,
+          suggestion: "Use ConcurrentDictionary/ImmutableCollections, change to Scoped lifetime, or add lock synchronization"
+        });
+      }
+    }
+  }
+  return patterns;
+}
+
+// src/analysis/chaos/state-detector.ts
+init_logging();
+
+// src/analysis/chaos/race-detector.ts
+init_logging();
+var HIDDEN_ASYNC_APIS = [
+  // Storage APIs - synchronous but with I/O delays
+  "localStorage",
+  "sessionStorage",
+  "indexedDB",
+  "caches",
+  // Cache API
+  // DOM APIs with async rendering effects
+  "requestAnimationFrame",
+  "requestIdleCallback",
+  "IntersectionObserver",
+  "MutationObserver",
+  "ResizeObserver",
+  "PerformanceObserver",
+  // Network/Communication
+  "fetch",
+  "XMLHttpRequest",
+  "WebSocket",
+  "EventSource",
+  "BroadcastChannel",
+  "SharedWorker",
+  "ServiceWorker",
+  // Timers
+  "setTimeout",
+  "setInterval",
+  "queueMicrotask",
+  // History API - can trigger events async
+  "history.pushState",
+  "history.replaceState",
+  // Clipboard API
+  "navigator.clipboard",
+  // Geolocation
+  "navigator.geolocation",
+  // Media APIs
+  "MediaRecorder",
+  "RTCPeerConnection",
+  // File APIs
+  "FileReader",
+  "FileWriter",
+  // C# Task-based async APIs
+  "Task.Run",
+  "Task.Factory.StartNew",
+  "Task.WhenAll",
+  "Task.WhenAny",
+  "Task.Delay",
+  "Parallel.ForEach",
+  "Parallel.For",
+  "Parallel.ForEachAsync",
+  "ThreadPool.QueueUserWorkItem",
+  "Channel.",
+  "Timer",
+  "PeriodicTimer"
+];
+var ASYNC_BEHAVIOR_PATTERNS = [
+  /\.addEventListener\s*\(/,
+  /\.on[A-Z]\w+\s*=/,
+  /new\s+Promise\s*\(/,
+  /\.then\s*\(/,
+  /\.catch\s*\(/,
+  /\.finally\s*\(/,
+  /callback/i,
+  /handler/i,
+  /listener/i,
+  /\.subscribe\s*\(/,
+  /\.pipe\s*\(/,
+  /rxjs/i,
+  /observable/i,
+  /subject/i,
+  /\$\./,
+  // jQuery async patterns
+  /emit/i,
+  /dispatch/i,
+  /broadcast/i,
+  // C# async patterns
+  /async\s+Task/,
+  /async\s+ValueTask/,
+  /\.ConfigureAwait\(/,
+  /CancellationToken/,
+  /IAsyncEnumerable/
+];
+var RaceDetector = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  _entityCache = null;
+  /** Pre-loaded relationship lookup: entityId → Relationship[] */
+  _relLookup = null;
+  /** Cache "is parent async" result per entityId to avoid re-processing */
+  _relCache = /* @__PURE__ */ new Map();
+  /**
+   * Set pre-loaded entity cache to avoid N+1 DB queries.
+   * Call before analyzeRaces() and clear after with clearEntityCache().
+   */
+  setEntityCache(entities) {
+    this._entityCache = new Map(entities.map((e) => [e.id, e]));
+  }
+  /** Set pre-loaded relationship lookup to avoid per-entity DB queries */
+  setRelationshipCache(lookup) {
+    this._relLookup = lookup;
+  }
+  clearEntityCache() {
+    this._entityCache = null;
+    this._relLookup = null;
+    this._relCache.clear();
+  }
+  /** Lookup entity from cache first, fallback to DB */
+  async getEntityCached(id) {
+    if (this._entityCache) {
+      return this._entityCache.get(id) || null;
+    }
+    return this.storage.getEntity(id);
+  }
+  /**
+   * Analyze state operations for race conditions
+   */
+  async analyzeRaces(stateIdentifier, operations) {
+    const readers = operations.filter((op) => op.operationType === "read" || op.operationType === "check");
+    const writers = operations.filter(
+      (op) => op.operationType === "write" || op.operationType === "initialize" || op.operationType === "emit"
+    );
+    const tMut = performance.now();
+    const mutations = await this.analyzeMutations(writers);
+    const dtMut = performance.now() - tMut;
+    if (dtMut > 200) {
+      log.w("CHAOS_RACE", "slow_mutations", {
+        id: stateIdentifier,
+        writers: writers.length,
+        ms: +dtMut.toFixed(0),
+        cached: !!this._entityCache
+      });
+    }
+    const factors = this.calculateRiskFactors(mutations);
+    const conflicts = this.detectConflicts(stateIdentifier, mutations, readers);
+    const raceRisk = this.calculateRaceRisk(factors, conflicts);
+    return {
+      stateIdentifier,
+      readers: readers.length,
+      writers: writers.length,
+      asyncWriters: mutations.filter((m) => m.isAsync).length,
+      unprotectedWriters: mutations.filter((m) => !m.hasLock).length,
+      raceRisk,
+      raceReason: this.generateRaceReason(factors, conflicts),
+      conflicts,
+      mutations
+    };
+  }
+  /**
+   * Convert state operations to detailed mutation points.
+   * Uses parallel async context detection for better throughput.
+   */
+  async analyzeMutations(writers) {
+    const asyncResults = await Promise.all(writers.map((w) => this.isAsyncContext(w)));
+    return writers.map((writer, i) => ({
+      file: writer.file,
+      line: writer.line,
+      entityId: writer.entityId,
+      entityName: writer.entityName,
+      mutationType: this.classifyMutation(writer),
+      condition: this.extractCondition(writer.context),
+      isAsync: asyncResults[i],
+      hasLock: this.detectLockPattern(writer.code, writer.context),
+      code: writer.code
+    }));
+  }
+  /**
+   * Check if operation is in async context
+   * Includes detection of hidden async APIs that appear synchronous.
+   * Uses entity cache to avoid N+1 DB queries.
+   */
+  async isAsyncContext(operation) {
+    const codeToCheck = `${operation.code}
+${operation.context || ""}`;
+    if (/async\s|await\s|\.then\(|Promise|setTimeout|setInterval|\.subscribe\(/.test(codeToCheck)) {
+      return true;
+    }
+    for (const api of HIDDEN_ASYNC_APIS) {
+      if (codeToCheck.includes(api)) return true;
+    }
+    for (const pattern of ASYNC_BEHAVIOR_PATTERNS) {
+      if (pattern.test(codeToCheck)) return true;
+    }
+    if (!operation.entityId) return false;
+    try {
+      const entity = await this.getEntityCached(operation.entityId);
+      if (!entity) return false;
+      if (entity.language === "csharp" || entity.metadata?.language === "csharp") {
+        if (entity.metadata?.modifiers?.includes("async")) return true;
+        if (/Task|ValueTask/.test(entity.metadata?.returnType || "")) return true;
+      }
+      const code = entity.code || "";
+      if (/^async\s/.test(code) || /async\s+function/.test(code)) return true;
+      for (const api of HIDDEN_ASYNC_APIS) {
+        if (code.includes(api)) return true;
+      }
+      for (const pattern of ASYNC_BEHAVIOR_PATTERNS) {
+        if (pattern.test(code)) return true;
+      }
+      if (this._relCache.has(operation.entityId)) {
+        return this._relCache.get(operation.entityId);
+      }
+      const relationships = this._relLookup?.get(operation.entityId) || await this.storage.getRelationshipsForEntity(operation.entityId);
+      let parentIsAsync = false;
+      for (const rel of relationships) {
+        if (rel.type === "contains" /* CONTAINS */) {
+          const parent = await this.getEntityCached(rel.fromId);
+          if (parent?.name && /handler|listener|callback|on[A-Z]/i.test(parent.name)) {
+            parentIsAsync = true;
+            break;
+          }
+        }
+      }
+      this._relCache.set(operation.entityId, parentIsAsync);
+      if (parentIsAsync) return true;
+    } catch {
+    }
+    return false;
+  }
+  /**
+   * Detect if mutation is protected by lock/mutex pattern
+   */
+  detectLockPattern(code, context) {
+    const lockPatterns = [
+      /mutex/i,
+      /lock\(/i,
+      /semaphore/i,
+      /synchronized/i,
+      /atomic/i,
+      /\.lock\(\)/,
+      /await\s+.*lock/i,
+      /critical\s*section/i,
+      /with\s*lock/i,
+      // C# synchronization primitives
+      /\block\s*\(/,
+      /SemaphoreSlim/,
+      /Monitor\.(Enter|Exit|TryEnter)/,
+      /Interlocked\./,
+      /ReaderWriterLockSlim/,
+      /SpinLock/,
+      /Volatile\.(Read|Write)/
+    ];
+    const combined = `${code}
+${context}`;
+    return lockPatterns.some((p) => p.test(combined));
+  }
+  /**
+   * Extract guard condition from context
+   */
+  extractCondition(context) {
+    const ifMatch = context.match(/if\s*\(([^)]+)\)/);
+    if (ifMatch?.[1]) {
+      return ifMatch[1].trim();
+    }
+    const ternaryMatch = context.match(/([^?]+)\s*\?/);
+    if (ternaryMatch?.[1] && ternaryMatch[1].length < 50) {
+      return ternaryMatch[1].trim();
+    }
+    const caseMatch = context.match(/case\s+([^:]+):/);
+    if (caseMatch?.[1]) {
+      return `case ${caseMatch[1].trim()}`;
+    }
+    return void 0;
+  }
+  /**
+   * Classify mutation type from operation
+   */
+  classifyMutation(op) {
+    const code = op.code.toLowerCase();
+    if (/=\s*(null|undefined|false|0|''|""|``)\s*[;,)]/.test(code) || /\.(clear|reset)\(\)/.test(code)) {
+      return "reset";
+    }
+    if (/\+\+|--|\+=\s*1|-=\s*1/.test(code)) {
+      return "increment";
+    }
+    if (/=\s*!/.test(code)) {
+      return "toggle";
+    }
+    if (op.context && /if\s*\(/.test(op.context)) {
+      return "conditional-write";
+    }
+    return "write";
+  }
+  /**
+   * Calculate risk factors from mutations
+   */
+  calculateRiskFactors(mutations) {
+    const conditions = mutations.filter((m) => m.condition).map((m) => m.condition);
+    const uniqueConditions = new Set(conditions);
+    let oppositeConditions = 0;
+    for (const cond of uniqueConditions) {
+      const negated = cond.startsWith("!") ? cond.slice(1) : `!${cond}`;
+      if (uniqueConditions.has(negated)) {
+        oppositeConditions++;
+      }
+    }
+    const conditionCounts = /* @__PURE__ */ new Map();
+    for (const cond of conditions) {
+      conditionCounts.set(cond, (conditionCounts.get(cond) || 0) + 1);
+    }
+    const sharedConditions = Array.from(conditionCounts.values()).filter((c) => c > 1).length;
+    return {
+      writerCount: mutations.length,
+      asyncBoundaries: mutations.filter((m) => m.isAsync).length,
+      sharedConditions,
+      oppositeConditions: oppositeConditions / 2,
+      // Pairs
+      hasLocks: mutations.some((m) => m.hasLock),
+      resetPoints: mutations.filter((m) => m.mutationType === "reset").length
+    };
+  }
+  /**
+   * Detect specific race conflict patterns
+   */
+  detectConflicts(stateIdentifier, mutations, _readers) {
+    const conflicts = [];
+    const resets = mutations.filter((m) => m.mutationType === "reset");
+    if (resets.length >= 2) {
+      conflicts.push({
+        pattern: "competing-resets",
+        severity: this.assessConflictSeverity(resets),
+        stateIdentifier,
+        description: `${resets.length} places reset ${stateIdentifier}`,
+        locations: resets,
+        explanation: `Multiple functions reset ${stateIdentifier} to initial value. If called concurrently, state may be reset while another function expects it to be set.`,
+        suggestion: "Centralize reset logic in a single function or use state machine pattern"
+      });
+    }
+    const conditionalWrites = mutations.filter((m) => m.mutationType === "conditional-write" && !m.hasLock);
+    if (conditionalWrites.length >= 2) {
+      const conditionGroups = /* @__PURE__ */ new Map();
+      for (const m of conditionalWrites) {
+        if (m.condition) {
+          const key = m.condition.replace(/\s+/g, "");
+          let arr = conditionGroups.get(key);
+          if (!arr) {
+            arr = [];
+            conditionGroups.set(key, arr);
+          }
+          arr.push(m);
+        }
+      }
+      for (const [condition, group] of conditionGroups) {
+        if (group.length >= 2) {
+          conflicts.push({
+            pattern: "check-then-act",
+            severity: "high",
+            stateIdentifier,
+            description: `${group.length} places check "${condition}" then modify ${stateIdentifier}`,
+            locations: group,
+            sharedCondition: condition,
+            explanation: `Multiple functions check the same condition before modifying state. Between check and act, another function may change the state.`,
+            suggestion: "Use atomic compare-and-swap, mutex, or combine into single handler"
+          });
+        }
+      }
+    }
+    const asyncMutations = mutations.filter((m) => m.isAsync && !m.hasLock);
+    if (asyncMutations.length >= 2) {
+      conflicts.push({
+        pattern: "async-boundary",
+        severity: "high",
+        stateIdentifier,
+        description: `${asyncMutations.length} async operations modify ${stateIdentifier} without synchronization`,
+        locations: asyncMutations,
+        explanation: `Async operations can interleave unpredictably. One operation may overwrite changes from another.`,
+        suggestion: "Add mutex/lock or use queue-based state updates"
+      });
+    }
+    const oppositeGroups = this.findOppositeConditionGroups(mutations);
+    for (const group of oppositeGroups) {
+      conflicts.push({
+        pattern: "competing-mutations",
+        severity: "critical",
+        stateIdentifier,
+        description: `Functions with opposite conditions both modify ${stateIdentifier}`,
+        locations: group,
+        explanation: `Functions checking opposite conditions (e.g., "if (x)" vs "if (!x)") both modify the state. This is a classic race condition pattern where both may execute simultaneously.`,
+        suggestion: "Merge into single handler with exclusive logic, or add explicit synchronization"
+      });
+    }
+    const handlerMutations = mutations.filter((m) => /handler|listener|on[A-Z]|callback/i.test(m.entityName));
+    if (handlerMutations.length >= 2) {
+      conflicts.push({
+        pattern: "event-handler-race",
+        severity: "medium",
+        stateIdentifier,
+        description: `${handlerMutations.length} event handlers modify ${stateIdentifier}`,
+        locations: handlerMutations,
+        explanation: `Multiple event handlers modify shared state. Event ordering may vary, causing unpredictable state.`,
+        suggestion: "Consolidate handlers or use event queue with single consumer"
+      });
+    }
+    return conflicts;
+  }
+  /**
+   * Find groups of mutations with opposite conditions
+   */
+  findOppositeConditionGroups(mutations) {
+    const groups = [];
+    const processed = /* @__PURE__ */ new Set();
+    for (let i = 0; i < mutations.length; i++) {
+      const mutationI = mutations[i];
+      if (processed.has(i) || !mutationI || !mutationI.condition) continue;
+      const cond = mutationI.condition;
+      const normalizedCond = cond.replace(/\s+/g, "");
+      const negatedCond = cond.startsWith("!") ? cond.slice(1).replace(/\s+/g, "") : `!${normalizedCond}`;
+      const opposites = [mutationI];
+      processed.add(i);
+      for (let j = i + 1; j < mutations.length; j++) {
+        const mutationJ = mutations[j];
+        if (processed.has(j) || !mutationJ || !mutationJ.condition) continue;
+        const otherCond = mutationJ.condition.replace(/\s+/g, "");
+        if (otherCond === negatedCond || `!${otherCond}` === normalizedCond) {
+          opposites.push(mutationJ);
+          processed.add(j);
+        }
+      }
+      if (opposites.length >= 2) {
+        groups.push(opposites);
+      }
+    }
+    return groups;
+  }
+  /**
+   * Assess severity of a conflict based on mutations
+   */
+  assessConflictSeverity(mutations) {
+    const hasAsync = mutations.some((m) => m.isAsync);
+    const allUnprotected = mutations.every((m) => !m.hasLock);
+    const count = mutations.length;
+    if (hasAsync && allUnprotected && count >= 3) return "critical";
+    if (hasAsync && allUnprotected) return "high";
+    if (count >= 3 && allUnprotected) return "high";
+    if (count >= 2 && allUnprotected) return "medium";
+    return "low";
+  }
+  /**
+   * Calculate overall race risk from factors and conflicts
+   */
+  calculateRaceRisk(factors, conflicts) {
+    let risk = "none";
+    if (factors.writerCount === 1) {
+      return "none";
+    }
+    if (factors.writerCount >= 2) {
+      risk = "low";
+    }
+    if (factors.asyncBoundaries >= 2 && !factors.hasLocks) {
+      risk = "high";
+    }
+    if (factors.oppositeConditions >= 1) {
+      risk = "high";
+    }
+    if (factors.resetPoints >= 2 && factors.asyncBoundaries >= 1) {
+      risk = "critical";
+    }
+    for (const conflict of conflicts) {
+      if (this.riskLevel(conflict.severity) > this.riskLevel(risk)) {
+        risk = conflict.severity;
+      }
+    }
+    return risk;
+  }
+  /**
+   * Convert risk to numeric level for comparison
+   */
+  riskLevel(risk) {
+    const levels = {
+      none: 0,
+      low: 1,
+      medium: 2,
+      high: 3,
+      critical: 4
+    };
+    return levels[risk];
+  }
+  /**
+   * Generate human-readable race reason
+   */
+  generateRaceReason(factors, conflicts) {
+    if (factors.writerCount <= 1) {
+      return void 0;
+    }
+    const parts = [];
+    parts.push(`${factors.writerCount} writers`);
+    if (factors.asyncBoundaries > 0) {
+      parts.push(`${factors.asyncBoundaries} async`);
+    }
+    if (!factors.hasLocks && factors.writerCount >= 2) {
+      parts.push("no sync");
+    }
+    if (conflicts.length > 0) {
+      const patterns = [...new Set(conflicts.map((c) => c.pattern))];
+      parts.push(`patterns: ${patterns.join(", ")}`);
+    }
+    return parts.join(", ");
+  }
+};
+
+// src/analysis/chaos/state-detector.ts
+function buildRelationshipLookup(relationships) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const rel of relationships) {
+    let fromArr = lookup.get(rel.fromId);
+    if (!fromArr) {
+      fromArr = [];
+      lookup.set(rel.fromId, fromArr);
+    }
+    fromArr.push(rel);
+    if (rel.toId !== rel.fromId) {
+      let toArr = lookup.get(rel.toId);
+      if (!toArr) {
+        toArr = [];
+        lookup.set(rel.toId, toArr);
+      }
+      toArr.push(rel);
+    }
+  }
+  return lookup;
+}
+var StateDetector = class {
+  constructor(storage) {
+    this.storage = storage;
+    this.raceDetector = new RaceDetector(storage);
+  }
+  raceDetector;
+  _cachedEntities = null;
+  /** Pre-loaded functions/methods for body scanning — shared across all identifiers */
+  _cachedFunctions = null;
+  /** Pre-loaded relationships indexed by entityId for O(1) lookup */
+  _relLookup = null;
+  async detectPatterns(options, cachedEntities, relLookup) {
+    const t0 = performance.now();
+    this._cachedEntities = cachedEntities || await this.storage.getAllEntities();
+    this._relLookup = relLookup || null;
+    const patterns = [];
+    this.raceDetector.setEntityCache(this._cachedEntities);
+    if (this._relLookup) {
+      this.raceDetector.setRelationshipCache(this._relLookup);
+    }
+    const tFns = performance.now();
+    this._cachedFunctions = await this.storage.searchEntities({
+      types: ["function" /* FUNCTION */, "method" /* METHOD */, "constructor"]
+    });
+    log.i("CHAOS_DET", "preload_functions", {
+      count: this._cachedFunctions.length,
+      ms: +(performance.now() - tFns).toFixed(0)
+    });
+    if (options.stateIdentifiers && options.stateIdentifiers.length > 0) {
+      for (const identifier of options.stateIdentifiers) {
+        const pattern = await this.analyzeIdentifier(identifier);
+        if (pattern) patterns.push(pattern);
+      }
+      log.i("CHAOS_DET", "manual_identifiers", {
+        count: options.stateIdentifiers.length,
+        matched: patterns.length,
+        ms: +(performance.now() - t0).toFixed(0)
+      });
+    } else if (options.autoDetect) {
+      const tAutoStart = performance.now();
+      const identifiers = this.autoDetectStateIdentifiers(this._cachedEntities);
+      log.i("CHAOS_DET", "autoDetect", {
+        candidates: identifiers.length,
+        fromEntities: this._cachedEntities.length,
+        ms: +(performance.now() - tAutoStart).toFixed(0)
+      });
+      for (let i = 0; i < identifiers.length; i++) {
+        const tIdent = performance.now();
+        const pattern = await this.analyzeIdentifier(identifiers[i]);
+        if (pattern) patterns.push(pattern);
+        const dtIdent = performance.now() - tIdent;
+        if (dtIdent > 1e3) {
+          log.w("CHAOS_DET", "slow_identifier", {
+            identifier: identifiers[i],
+            index: i,
+            ms: +dtIdent.toFixed(0),
+            ops: pattern?.operations.length || 0,
+            writers: pattern?.raceAnalysis.writers || 0
+          });
+        }
+      }
+      log.i("CHAOS_DET", "all_identifiers", {
+        total: identifiers.length,
+        matched: patterns.length,
+        ms: +(performance.now() - t0).toFixed(0)
+      });
+    }
+    this._cachedEntities = null;
+    this._cachedFunctions = null;
+    this._relLookup = null;
+    this.raceDetector.clearEntityCache();
+    return patterns.sort((a, b) => {
+      const riskOrder = { critical: 0, high: 1, medium: 2, low: 3, none: 4 };
+      return riskOrder[a.raceAnalysis.raceRisk] - riskOrder[b.raceAnalysis.raceRisk];
+    });
+  }
+  autoDetectStateIdentifiers(entities) {
+    const identifiers = /* @__PURE__ */ new Map();
+    for (const entity of entities) {
+      const lang = entity.language || entity.metadata?.language;
+      const isCSharp = lang === "csharp";
+      const typeStr = entity.type;
+      const isStateType = entity.type === "variable" /* VARIABLE */ || entity.type === "constant" /* CONSTANT */ || typeStr === "field" || typeStr === "property";
+      if (!isStateType) continue;
+      const isState = isCSharp ? isCSharpStateIdentifier(entity) : isStateIdentifier(entity.name);
+      if (isState) {
+        identifiers.set(entity.name, (identifiers.get(entity.name) || 0) + 1);
+      }
+    }
+    return Array.from(identifiers.entries()).sort((a, b) => b[1] - a[1]).slice(0, 20).map(([name]) => name);
+  }
+  async analyzeIdentifier(identifier) {
+    const tOps = performance.now();
+    const operations = await this.findStateOperations(identifier);
+    const tOpsEnd = performance.now();
+    if (operations.length === 0) return null;
+    const relatedIdentifiers = this.findRelatedIdentifiers(identifier);
+    const tRace = performance.now();
+    const raceAnalysis = await this.raceDetector.analyzeRaces(identifier, operations);
+    const tRaceEnd = performance.now();
+    log.d("CHAOS_DET", "analyzeIdentifier", {
+      id: identifier,
+      ops: operations.length,
+      opsMs: +(tOpsEnd - tOps).toFixed(0),
+      raceMs: +(tRaceEnd - tRace).toFixed(0),
+      writers: raceAnalysis.writers,
+      risk: raceAnalysis.raceRisk
+    });
+    return {
+      identifier,
+      type: this.inferStateType(identifier, operations),
+      scope: this.inferScope(operations),
+      operations,
+      relatedIdentifiers,
+      raceAnalysis
+    };
+  }
+  async findStateOperations(identifier) {
+    const tStart = performance.now();
+    const operations = [];
+    const variables = await this.storage.searchEntities({
+      namePattern: identifier,
+      types: ["variable" /* VARIABLE */, "constant" /* CONSTANT */, "field", "property"]
+    });
+    for (const entity of variables) {
+      operations.push({
+        file: entity.filePath,
+        line: entity.location?.start?.line || 0,
+        column: entity.location?.start?.column || 0,
+        entityId: entity.id,
+        entityName: entity.name,
+        operationType: "initialize",
+        code: entity.code?.slice(0, 200) || "",
+        context: "",
+        isDefensive: false,
+        depth: 0
+      });
+    }
+    const entityLookup = /* @__PURE__ */ new Map();
+    if (this._cachedEntities) {
+      for (const e of this._cachedEntities) {
+        entityLookup.set(e.id, e);
+      }
+    }
+    for (const variable of variables) {
+      const relationships = this._relLookup?.get(variable.id) || await this.storage.getRelationshipsForEntity(variable.id);
+      const refIds = [];
+      for (const rel of relationships) {
+        if (rel.type === "references" /* REFERENCES */) {
+          const refId = rel.fromId === variable.id ? rel.toId : rel.fromId;
+          if (refId !== variable.id && !entityLookup.has(refId)) {
+            refIds.push(refId);
+          }
+        }
+      }
+      if (refIds.length > 0) {
+        const fetched = await this.storage.getEntitiesBatch(refIds);
+        for (const [id, e] of fetched) {
+          entityLookup.set(id, e);
+        }
+      }
+      for (const rel of relationships) {
+        if (rel.type === "references" /* REFERENCES */) {
+          const refId = rel.fromId === variable.id ? rel.toId : rel.fromId;
+          const refEntity = entityLookup.get(refId) || null;
+          if (refEntity && refEntity.id !== variable.id) {
+            const opType = await this.classifyOperation(refEntity, identifier);
+            operations.push({
+              file: refEntity.filePath,
+              line: refEntity.location?.start?.line || 0,
+              column: refEntity.location?.start?.column || 0,
+              entityId: refEntity.id,
+              entityName: refEntity.name,
+              operationType: opType,
+              code: refEntity.code?.slice(0, 200) || "",
+              context: await this.getContext(refEntity),
+              isDefensive: this.isDefensiveCode(refEntity.code || ""),
+              depth: 1
+            });
+          }
+        }
+      }
+    }
+    const functions = this._cachedFunctions || await this.storage.searchEntities({
+      types: ["function" /* FUNCTION */, "method" /* METHOD */, "constructor"]
+    });
+    const seenEntityIds = new Set(operations.map((op) => op.entityId));
+    const identifierRegex = new RegExp(`\\b${identifier}\\b`);
+    for (const fn of functions) {
+      if (!fn.code || seenEntityIds.has(fn.id)) continue;
+      if (!identifierRegex.test(fn.code)) continue;
+      const opType = this.classifyOperationFromCode(fn.code, identifier);
+      seenEntityIds.add(fn.id);
+      operations.push({
+        file: fn.filePath,
+        line: fn.location?.start?.line || 0,
+        column: fn.location?.start?.column || 0,
+        entityId: fn.id,
+        entityName: fn.name,
+        operationType: opType,
+        code: this.extractRelevantCode(fn.code, identifier),
+        context: "",
+        isDefensive: this.isDefensiveCode(fn.code),
+        depth: 1
+      });
+    }
+    const dtOps = performance.now() - tStart;
+    if (dtOps > 500) {
+      log.w("CHAOS_DET", "slow_findOps", {
+        identifier,
+        vars: variables.length,
+        fns: functions.length,
+        ops: operations.length,
+        ms: +dtOps.toFixed(0)
+      });
+    }
+    return operations;
+  }
+  /**
+   * Classify operation type from entity
+   */
+  async classifyOperation(entity, identifier) {
+    const code = entity.code || "";
+    return this.classifyOperationFromCode(code, identifier);
+  }
+  /**
+   * Classify operation type from code string
+   */
+  classifyOperationFromCode(code, identifier) {
+    const writePattern = new RegExp(`${identifier}\\s*=(?!=)`, "g");
+    if (writePattern.test(code)) {
+      const resetPattern = new RegExp(`${identifier}\\s*=\\s*(null|undefined|false|0|''|""|\\[\\]|\\{\\})`, "g");
+      if (resetPattern.test(code)) {
+        return "write";
+      }
+      return "write";
+    }
+    if (/\.next\(|\.emit\(/.test(code)) return "emit";
+    if (/\.subscribe\(|\.pipe\(/.test(code)) return "subscribe";
+    if (/\block\s*\(/.test(code)) return "write";
+    if (/Interlocked\./.test(code)) return "write";
+    if (/\bawait\b/.test(code)) return "read";
+    const checkPattern = new RegExp(`if\\s*\\([^)]*${identifier}`, "g");
+    if (checkPattern.test(code)) return "check";
+    const passPattern = new RegExp(`\\(\\s*[^)]*${identifier}[^)]*\\)`, "g");
+    if (passPattern.test(code)) return "pass";
+    return "read";
+  }
+  /**
+   * Extract the most relevant code snippet containing the identifier
+   */
+  extractRelevantCode(code, identifier) {
+    const lines = code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line?.includes(identifier)) {
+        const start = Math.max(0, i - 1);
+        const end = Math.min(lines.length, i + 2);
+        return lines.slice(start, end).join("\n").slice(0, 200);
+      }
+    }
+    return code.slice(0, 200);
+  }
+  /**
+   * Get surrounding context for an entity
+   */
+  async getContext(_entity) {
+    return "";
+  }
+  /**
+   * Check if code contains defensive patterns
+   */
+  isDefensiveCode(code) {
+    return /!==?\s*(null|undefined)|typeof\s+\w+|&&\s*\w+\.|try\s*{|\?\?|\?\./i.test(code);
+  }
+  /**
+   * Find identifiers with similar names
+   */
+  findRelatedIdentifiers(identifier) {
+    const related = [];
+    const entities = this._cachedEntities || [];
+    const variations = [
+      `_${identifier}`,
+      `${identifier}_`,
+      `${identifier}Value`,
+      `${identifier}State`,
+      `current${identifier.charAt(0).toUpperCase()}${identifier.slice(1)}`,
+      `saved${identifier.charAt(0).toUpperCase()}${identifier.slice(1)}`,
+      `old${identifier.charAt(0).toUpperCase()}${identifier.slice(1)}`,
+      `new${identifier.charAt(0).toUpperCase()}${identifier.slice(1)}`
+    ];
+    for (const entity of entities) {
+      if (variations.includes(entity.name) || entity.name.toLowerCase().includes(identifier.toLowerCase())) {
+        if (entity.name !== identifier && !related.includes(entity.name)) {
+          related.push(entity.name);
+        }
+      }
+    }
+    return related.slice(0, 5);
+  }
+  /**
+   * Infer TypeScript type from operations
+   */
+  inferStateType(identifier, operations) {
+    for (const op of operations) {
+      if (op.operationType === "initialize" && op.code) {
+        const typeMatch = op.code.match(new RegExp(`${identifier}\\s*:\\s*([\\w<>\\[\\]|&]+)`));
+        if (typeMatch?.[1]) return typeMatch[1];
+        if (/=\s*(true|false)/.test(op.code)) return "boolean";
+        if (/=\s*\d+/.test(op.code)) return "number";
+        if (/=\s*['"`]/.test(op.code)) return "string";
+        if (/=\s*\[/.test(op.code)) return "array";
+        if (/=\s*\{/.test(op.code)) return "object";
+        if (/=\s*new\s+(\w+)/.test(op.code)) {
+          const match = op.code.match(/=\s*new\s+(\w+)/);
+          return match?.[1] ? match[1] : "unknown";
+        }
+      }
+    }
+    return "unknown";
+  }
+  /**
+   * Infer scope from operations
+   */
+  inferScope(operations) {
+    const files = new Set(operations.map((op) => op.file));
+    if (files.size === 1) return "local";
+    if (files.size <= 3) return "module";
+    return "global";
+  }
+};
+
+// src/analysis/chaos/chaos-analyzer.ts
+var ChaosAnalyzer = class {
+  detector;
+  storage;
+  _csharpPatterns = [];
+  constructor(storage) {
+    this.storage = storage;
+    this.detector = new StateDetector(storage);
+  }
+  /** C# anti-patterns detected in last analyze() call */
+  get csharpPatterns() {
+    return this._csharpPatterns;
+  }
+  async analyze(options) {
+    const t0 = performance.now();
+    const allEntities = await this.storage.getAllEntities();
+    const tEntities = performance.now();
+    log.i("CHAOS", "1_getAllEntities", { count: allEntities.length, ms: +(tEntities - t0).toFixed(0) });
+    const allRelationships = await this.storage.getAllRelationships();
+    const relLookup = buildRelationshipLookup(allRelationships);
+    const tRels = performance.now();
+    log.i("CHAOS", "1b_getAllRelationships", {
+      count: allRelationships.length,
+      indexKeys: relLookup.size,
+      ms: +(tRels - tEntities).toFixed(0)
+    });
+    const patterns = await this.detector.detectPatterns(options, allEntities, relLookup);
+    const tPatterns = performance.now();
+    log.i("CHAOS", "2_detectPatterns", { patterns: patterns.length, ms: +(tPatterns - tEntities).toFixed(0) });
+    const results = [];
+    try {
+      this._csharpPatterns = detectCSharpChaosPatterns(allEntities);
+    } catch {
+      this._csharpPatterns = [];
+    }
+    const tCsharp = performance.now();
+    log.i("CHAOS", "3_csharpPatterns", { count: this._csharpPatterns.length, ms: +(tCsharp - tPatterns).toFixed(0) });
+    for (const pattern of patterns) {
+      const { raceAnalysis } = pattern;
+      const files = new Set(pattern.operations.map((op) => op.file));
+      const chaosScore = this.calculateChaosScore(pattern, raceAnalysis);
+      const divergenceRisk = this.assessDivergenceRisk(pattern, raceAnalysis);
+      const hotspots = this.generateHotspots(pattern, raceAnalysis);
+      const quickFixes = this.generateQuickFixes(pattern, raceAnalysis);
+      const strategy = this.chooseStrategy(pattern, raceAnalysis);
+      const summary = {
+        overview: {
+          stateIdentifier: pattern.identifier,
+          totalFiles: files.size,
+          totalOperations: pattern.operations.length,
+          chaosScore,
+          divergenceRisk,
+          raceRisk: raceAnalysis.raceRisk,
+          writers: raceAnalysis.writers,
+          conflicts: raceAnalysis.conflicts.length
+        },
+        hotspots,
+        raceConflicts: raceAnalysis.conflicts.map((c) => ({
+          pattern: c.pattern,
+          severity: c.severity,
+          locations: c.locations.map((l) => `${l.file}:${l.line}`),
+          suggestion: c.suggestion
+        })),
+        quickFixes,
+        refactoringStrategy: strategy,
+        estimatedEffort: this.estimateEffort(pattern, raceAnalysis)
+      };
+      const writeOps = pattern.operations.filter(
+        (op) => op.operationType === "write" || op.operationType === "initialize" || op.operationType === "emit"
+      );
+      const mutationFiles = new Set(writeOps.map((op) => op.file));
+      results.push({
+        statePattern: pattern,
+        flowMap: {
+          stateIdentifier: pattern.identifier,
+          origin: {
+            file: pattern.operations[0]?.file || "",
+            line: pattern.operations[0]?.line || 0,
+            entityName: pattern.identifier,
+            type: "initialization",
+            code: pattern.operations[0]?.code || ""
+          },
+          nodes: [],
+          edges: [],
+          totalOperations: pattern.operations.length,
+          mutationPoints: raceAnalysis.writers,
+          maxDepth: Math.max(...pattern.operations.map((op) => op.depth), 0)
+        },
+        metrics: {
+          stateIdentifier: pattern.identifier,
+          coupling: {
+            score: Math.min(100, files.size * 15),
+            affectedComponents: pattern.operations.length,
+            sharedStateCount: pattern.relatedIdentifiers.length,
+            bidirectionalBindings: 0
+          },
+          defensive: {
+            nullChecks: pattern.operations.filter((op) => op.isDefensive).length,
+            typeGuards: 0,
+            defaultValues: 0,
+            tryCatch: 0,
+            localCopies: 0
+          },
+          mutationSpread: {
+            totalMutations: raceAnalysis.writers,
+            filesWithMutations: mutationFiles.size,
+            componentsWithMutations: raceAnalysis.mutations.length,
+            averageMutationsPerComponent: mutationFiles.size > 0 ? raceAnalysis.writers / mutationFiles.size : 0
+          },
+          divergenceRisk,
+          complexity: {
+            cyclomaticComplexity: 0,
+            cognitiveComplexity: 0
+          },
+          score: chaosScore
+        },
+        raceAnalysis,
+        refactoringPlan: {
+          stateIdentifier: pattern.identifier,
+          currentMetrics: {
+            stateIdentifier: pattern.identifier,
+            coupling: {
+              score: Math.min(100, files.size * 15),
+              affectedComponents: pattern.operations.length,
+              sharedStateCount: pattern.relatedIdentifiers.length,
+              bidirectionalBindings: 0
+            },
+            defensive: {
+              nullChecks: pattern.operations.filter((op) => op.isDefensive).length,
+              typeGuards: 0,
+              defaultValues: 0,
+              tryCatch: 0,
+              localCopies: 0
+            },
+            mutationSpread: {
+              totalMutations: raceAnalysis.writers,
+              filesWithMutations: mutationFiles.size,
+              componentsWithMutations: raceAnalysis.mutations.length,
+              averageMutationsPerComponent: mutationFiles.size > 0 ? raceAnalysis.writers / mutationFiles.size : 0
+            },
+            divergenceRisk,
+            complexity: {
+              cyclomaticComplexity: 0,
+              cognitiveComplexity: 0
+            },
+            score: chaosScore
+          },
+          strategy,
+          reasoning: this.generateReasoning(strategy, raceAnalysis),
+          steps: [],
+          newComponents: [],
+          benefits: {
+            reducedCoupling: strategy === "Service" ? 40 : strategy === "ImmutableState" ? 50 : 60,
+            reducedMutations: Math.floor(raceAnalysis.writers / 2),
+            reducedComplexity: raceAnalysis.conflicts.length > 0 ? 50 : 30,
+            improvedTestability: true,
+            improvedMaintainability: true,
+            estimatedLOCChange: 0
+          },
+          risks: raceAnalysis.conflicts.length > 0 ? ["\u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u0442\u0449\u0430\u0442\u0435\u043B\u044C\u043D\u043E\u0435 \u0442\u0435\u0441\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0435 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u0438"] : [],
+          prerequisites: []
+        },
+        summary,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    log.i("CHAOS", "4_total", {
+      entities: allEntities.length,
+      statePatterns: patterns.length,
+      csharpPatterns: this._csharpPatterns.length,
+      results: results.length,
+      totalMs: +(performance.now() - t0).toFixed(0)
+    });
+    return results;
+  }
+  /**
+   * Format results for AI consumption (compact, token-efficient)
+   */
+  formatForAI(results) {
+    if (results.length === 0 && this._csharpPatterns.length === 0) {
+      return "No state patterns detected.";
+    }
+    const output = ["# State Chaos Analysis\n"];
+    for (const result of results) {
+      const { summary, raceAnalysis } = result;
+      const { overview } = summary;
+      const riskEmoji = this.getRiskEmoji(overview.raceRisk);
+      output.push(`## ${riskEmoji} ${overview.stateIdentifier}`);
+      output.push(
+        `Chaos: ${overview.chaosScore}/100 | Files: ${overview.totalFiles} | Writers: ${overview.writers} | Race: ${overview.raceRisk}`
+      );
+      if (raceAnalysis.conflicts.length > 0) {
+        output.push("\n**\u26A0\uFE0F Race Conditions:**");
+        for (const conflict of raceAnalysis.conflicts) {
+          output.push(`- **${conflict.pattern}** (${conflict.severity})`);
+          output.push(`  ${conflict.explanation}`);
+          output.push(`  \u{1F4CD} ${conflict.locations.map((l) => `${l.entityName}:${l.line}`).join(", ")}`);
+          output.push(`  \u{1F4A1} ${conflict.suggestion}`);
+        }
+      }
+      if (summary.quickFixes.length > 0) {
+        output.push("\n**Quick Fixes:**");
+        for (const fix of summary.quickFixes) {
+          output.push(`- ${fix}`);
+        }
+      }
+      output.push(`
+**Strategy:** ${summary.refactoringStrategy}`);
+      output.push(`**Effort:** ${summary.estimatedEffort}
+`);
+      output.push("---\n");
+    }
+    if (this._csharpPatterns.length > 0) {
+      output.push(this.formatCSharpPatternsForAI());
+    }
+    return output.join("\n");
+  }
+  /**
+   * Format C# anti-patterns for AI consumption
+   */
+  formatCSharpPatternsForAI() {
+    const lines = ["\n# C# Anti-Patterns\n"];
+    const byPattern = /* @__PURE__ */ new Map();
+    for (const p of this._csharpPatterns) {
+      const arr = byPattern.get(p.pattern) || [];
+      arr.push(p);
+      byPattern.set(p.pattern, arr);
+    }
+    const severityEmoji = {
+      critical: "\u{1F534}",
+      high: "\u{1F7E0}",
+      medium: "\u{1F7E1}"
+    };
+    for (const [pattern, items] of byPattern) {
+      const sev = items[0].severity;
+      lines.push(`## ${severityEmoji[sev] || "\u26AA"} ${pattern} (${items.length} found)`);
+      for (const item of items.slice(0, 10)) {
+        lines.push(`- **${item.entityName}** ${item.filePath}:${item.line}`);
+        lines.push(`  ${item.description}`);
+        lines.push(`  \u{1F4A1} ${item.suggestion}`);
+      }
+      if (items.length > 10) {
+        lines.push(`  ... and ${items.length - 10} more`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format single result with full details
+   */
+  formatDetailed(result) {
+    const { statePattern: pattern, raceAnalysis, metrics, summary } = result;
+    const lines = [];
+    lines.push(`# \u0410\u043D\u0430\u043B\u0438\u0437 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F: ${pattern.identifier}`);
+    lines.push(`**\u0422\u0438\u043F:** ${pattern.type || "unknown"}`);
+    lines.push(`**Scope:** ${pattern.scope}`);
+    lines.push("");
+    lines.push("## \u041C\u0435\u0442\u0440\u0438\u043A\u0438");
+    lines.push(`- **Chaos Score:** ${metrics.score}/100`);
+    lines.push(`- **Divergence Risk:** ${metrics.divergenceRisk}`);
+    lines.push(`- **Race Risk:** ${raceAnalysis.raceRisk}`);
+    lines.push(`- **\u041E\u043F\u0435\u0440\u0430\u0446\u0438\u0439:** ${pattern.operations.length}`);
+    lines.push(`- **\u0424\u0430\u0439\u043B\u043E\u0432:** ${new Set(pattern.operations.map((op) => op.file)).size}`);
+    lines.push(`- **\u041F\u0438\u0441\u0430\u0442\u0435\u043B\u0435\u0439:** ${raceAnalysis.writers} (async: ${raceAnalysis.asyncWriters})`);
+    lines.push("");
+    if (raceAnalysis.conflicts.length > 0) {
+      lines.push("## \u26A0\uFE0F \u041E\u0431\u043D\u0430\u0440\u0443\u0436\u0435\u043D\u043D\u044B\u0435 \u0433\u043E\u043D\u043A\u0438");
+      for (const conflict of raceAnalysis.conflicts) {
+        lines.push(`### ${conflict.pattern} (${conflict.severity})`);
+        lines.push(`**\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435:** ${conflict.description}`);
+        lines.push(`**\u041E\u0431\u044A\u044F\u0441\u043D\u0435\u043D\u0438\u0435:** ${conflict.explanation}`);
+        lines.push("**\u041B\u043E\u043A\u0430\u0446\u0438\u0438:**");
+        for (const loc of conflict.locations) {
+          lines.push(`- \`${loc.entityName}\` \u0432 ${loc.file}:${loc.line}`);
+          if (loc.condition) {
+            lines.push(`  \u0423\u0441\u043B\u043E\u0432\u0438\u0435: \`${loc.condition}\``);
+          }
+        }
+        lines.push(`**\u0420\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0430\u0446\u0438\u044F:** ${conflict.suggestion}`);
+        lines.push("");
+      }
+    }
+    if (raceAnalysis.mutations.length > 0) {
+      lines.push("## \u0422\u043E\u0447\u043A\u0438 \u043C\u0443\u0442\u0430\u0446\u0438\u0438");
+      for (const mut of raceAnalysis.mutations) {
+        const flags = [];
+        if (mut.isAsync) flags.push("async");
+        if (!mut.hasLock) flags.push("no-lock");
+        const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
+        lines.push(`- **${mut.entityName}** (${mut.mutationType})${flagStr}`);
+        lines.push(`  ${mut.file}:${mut.line}`);
+        if (mut.condition) {
+          lines.push(`  \u0423\u0441\u043B\u043E\u0432\u0438\u0435: \`${mut.condition}\``);
+        }
+      }
+      lines.push("");
+    }
+    if (pattern.relatedIdentifiers.length > 0) {
+      lines.push("## \u0421\u0432\u044F\u0437\u0430\u043D\u043D\u044B\u0435 \u0438\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440\u044B");
+      lines.push(pattern.relatedIdentifiers.map((id) => `\`${id}\``).join(", "));
+      lines.push("");
+    }
+    lines.push("## \u0420\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0430\u0446\u0438\u0438");
+    lines.push(`**\u0421\u0442\u0440\u0430\u0442\u0435\u0433\u0438\u044F:** ${summary.refactoringStrategy}`);
+    lines.push(`**\u041E\u0431\u043E\u0441\u043D\u043E\u0432\u0430\u043D\u0438\u0435:** ${result.refactoringPlan.reasoning}`);
+    lines.push(`**Effort:** ${summary.estimatedEffort}`);
+    return lines.join("\n");
+  }
+  /**
+   * Calculate overall chaos score combining spread and race risk
+   */
+  calculateChaosScore(pattern, raceAnalysis) {
+    const baseScore = Math.min(50, pattern.operations.length * 3);
+    const fileScore = Math.min(20, new Set(pattern.operations.map((op) => op.file)).size * 5);
+    const raceScore = this.raceRiskToScore(raceAnalysis.raceRisk);
+    return Math.min(100, baseScore + fileScore + raceScore);
+  }
+  raceRiskToScore(risk) {
+    const scores = {
+      none: 0,
+      low: 5,
+      medium: 15,
+      high: 25,
+      critical: 30
+    };
+    return scores[risk];
+  }
+  /**
+   * Assess divergence risk combining chaos and race factors
+   */
+  assessDivergenceRisk(pattern, raceAnalysis) {
+    const opCount = pattern.operations.length;
+    const fileCount = new Set(pattern.operations.map((op) => op.file)).size;
+    const raceRisk = raceAnalysis.raceRisk;
+    if (raceRisk === "critical") return "critical";
+    if (raceRisk === "high" && opCount >= 10) return "critical";
+    if (raceRisk === "high" || fileCount >= 5 && opCount >= 15) return "high";
+    if (raceRisk === "medium" || fileCount >= 3 && opCount >= 8) return "medium";
+    return "low";
+  }
+  /**
+   * Generate hotspots from pattern and race analysis
+   */
+  generateHotspots(_pattern, raceAnalysis) {
+    const hotspots = [];
+    for (const conflict of raceAnalysis.conflicts) {
+      for (const loc of conflict.locations) {
+        hotspots.push({
+          file: loc.file,
+          entity: loc.entityName,
+          issues: [conflict.pattern, conflict.description],
+          priority: conflict.severity === "critical" || conflict.severity === "high" ? "high" : "medium"
+        });
+      }
+    }
+    for (const mut of raceAnalysis.mutations) {
+      if (mut.isAsync && !mut.hasLock) {
+        const existing = hotspots.find((h) => h.file === mut.file && h.entity === mut.entityName);
+        if (existing) {
+          existing.issues.push("unprotected async write");
+        } else {
+          hotspots.push({
+            file: mut.file,
+            entity: mut.entityName,
+            issues: ["unprotected async write"],
+            priority: "medium"
+          });
+        }
+      }
+    }
+    return hotspots.sort((a, b) => a.priority === "high" ? -1 : b.priority === "high" ? 1 : 0).slice(0, 5);
+  }
+  /**
+   * Generate quick fix suggestions
+   */
+  generateQuickFixes(pattern, raceAnalysis) {
+    const fixes = [];
+    if (raceAnalysis.conflicts.some((c) => c.pattern === "competing-resets")) {
+      fixes.push("\u041E\u0431\u044A\u0435\u0434\u0438\u043D\u0438\u0442\u0435 \u0444\u0443\u043D\u043A\u0446\u0438\u0438 \u0441\u0431\u0440\u043E\u0441\u0430 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F \u0432 \u0435\u0434\u0438\u043D\u044B\u0439 \u043C\u0435\u0442\u043E\u0434 reset()");
+    }
+    if (raceAnalysis.asyncWriters > 0 && raceAnalysis.unprotectedWriters > 0) {
+      fixes.push("\u0414\u043E\u0431\u0430\u0432\u044C\u0442\u0435 \u043C\u044C\u044E\u0442\u0435\u043A\u0441 \u0438\u043B\u0438 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 queue \u0434\u043B\u044F \u0430\u0441\u0438\u043D\u0445\u0440\u043E\u043D\u043D\u044B\u0445 \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0439");
+    }
+    if (raceAnalysis.conflicts.some((c) => c.pattern === "check-then-act")) {
+      fixes.push("\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 \u0430\u0442\u043E\u043C\u0430\u0440\u043D\u044B\u0435 \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u0438\u043B\u0438 compare-and-swap \u043F\u0430\u0442\u0442\u0435\u0440\u043D");
+    }
+    if (pattern.relatedIdentifiers.length > 2) {
+      fixes.push(`\u041A\u043E\u043D\u0441\u043E\u043B\u0438\u0434\u0438\u0440\u0443\u0439\u0442\u0435 \u0441\u0432\u044F\u0437\u0430\u043D\u043D\u044B\u0435 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0435: ${pattern.relatedIdentifiers.slice(0, 3).join(", ")}`);
+    }
+    if (new Set(pattern.operations.map((op) => op.file)).size > 3) {
+      fixes.push("\u0421\u043E\u0437\u0434\u0430\u0439\u0442\u0435 \u0446\u0435\u043D\u0442\u0440\u0430\u043B\u0438\u0437\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \u0441\u0435\u0440\u0432\u0438\u0441 \u0434\u043B\u044F \u0443\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u044F \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435\u043C");
+    }
+    const allCode = pattern.operations.map((op) => op.code).join("\n");
+    if (/async\s+void\b/.test(allCode)) {
+      fixes.push("\u0417\u0430\u043C\u0435\u043D\u0438\u0442\u0435 'async void' \u043D\u0430 'async Task' \u2014 async void \u043D\u0435 \u043E\u0431\u0440\u0430\u0431\u0430\u0442\u044B\u0432\u0430\u0435\u0442 \u0438\u0441\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F");
+    }
+    if (/static\b/.test(allCode) && !/readonly|const|ConcurrentDictionary/.test(allCode)) {
+      fixes.push("\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 ConcurrentDictionary \u0438\u043B\u0438 \u043F\u0435\u0440\u0435\u043C\u0435\u0441\u0442\u0438\u0442\u0435 state \u0432 DI-managed service");
+    }
+    if (/\.ctor|constructor/i.test(pattern.identifier) && pattern.operations.length > 10) {
+      fixes.push("\u0420\u0430\u0437\u0434\u0435\u043B\u0438\u0442\u0435 god-service \u043D\u0430 \u043C\u0435\u043D\u044C\u0448\u0438\u0435 \u0441\u0444\u043E\u043A\u0443\u0441\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0435 \u0441\u0435\u0440\u0432\u0438\u0441\u044B");
+    }
+    if (/async\s+Task/.test(allCode) && !/CancellationToken/.test(allCode)) {
+      fixes.push("\u0414\u043E\u0431\u0430\u0432\u044C\u0442\u0435 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 CancellationToken \u0432 async \u043C\u0435\u0442\u043E\u0434\u044B");
+    }
+    return fixes;
+  }
+  /**
+   * Choose refactoring strategy based on analysis
+   */
+  chooseStrategy(pattern, raceAnalysis) {
+    if (raceAnalysis.raceRisk === "critical" || raceAnalysis.conflicts.length >= 3) {
+      return "StateMachine";
+    }
+    const allCode = pattern.operations.map((op) => op.code).join("\n");
+    const isCSharpContext = /\bTask\b|\basync\s+Task\b|\bawait\b.*\.\w+Async\b/.test(allCode) || pattern.operations.some((op) => op.file.endsWith(".cs"));
+    if (isCSharpContext) {
+      if (/static\b/.test(allCode) && /Singleton|AddSingleton/.test(allCode)) {
+        return "DI_Lifetime";
+      }
+      if (raceAnalysis.raceRisk === "high" && raceAnalysis.asyncWriters > 2) {
+        return "Channel";
+      }
+      if (raceAnalysis.writers > 5 && raceAnalysis.unprotectedWriters > 3) {
+        return "ImmutableState";
+      }
+    }
+    if (raceAnalysis.raceRisk === "high" && raceAnalysis.asyncWriters > 2) {
+      return "EventBus";
+    }
+    const files = new Set(pattern.operations.map((op) => op.file)).size;
+    if (files > 5) {
+      return "Store";
+    }
+    if (pattern.operations.some((op) => op.angularPattern === "behavior_subject")) {
+      return "Service";
+    }
+    return "Service";
+  }
+  /**
+   * Generate reasoning for chosen strategy
+   */
+  generateReasoning(strategy, raceAnalysis) {
+    const reasons = {
+      StateMachine: `\u041E\u0431\u043D\u0430\u0440\u0443\u0436\u0435\u043D\u044B \u043A\u0440\u0438\u0442\u0438\u0447\u0435\u0441\u043A\u0438\u0435 \u0433\u043E\u043D\u043A\u0438 (${raceAnalysis.conflicts.length} \u043A\u043E\u043D\u0444\u043B\u0438\u043A\u0442\u043E\u0432). State machine \u043E\u0431\u0435\u0441\u043F\u0435\u0447\u0438\u0442 \u044F\u0432\u043D\u044B\u0435 \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u044B \u0438 \u043F\u0440\u0435\u0434\u043E\u0442\u0432\u0440\u0430\u0442\u0438\u0442 invalid states.`,
+      EventBus: `${raceAnalysis.asyncWriters} \u0430\u0441\u0438\u043D\u0445\u0440\u043E\u043D\u043D\u044B\u0445 \u043F\u0438\u0441\u0430\u0442\u0435\u043B\u0435\u0439 \u0441\u043E\u0437\u0434\u0430\u044E\u0442 \u043D\u0435\u043F\u0440\u0435\u0434\u0441\u043A\u0430\u0437\u0443\u0435\u043C\u043E\u0435 \u043F\u043E\u0432\u0435\u0434\u0435\u043D\u0438\u0435. Event-driven \u0430\u0440\u0445\u0438\u0442\u0435\u043A\u0442\u0443\u0440\u0430 \u0443\u043F\u043E\u0440\u044F\u0434\u043E\u0447\u0438\u0442 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F.`,
+      Store: "\u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0440\u0430\u0437\u0431\u0440\u043E\u0441\u0430\u043D\u043E \u043F\u043E \u043C\u043D\u043E\u0433\u0438\u043C \u0444\u0430\u0439\u043B\u0430\u043C. \u0426\u0435\u043D\u0442\u0440\u0430\u043B\u0438\u0437\u043E\u0432\u0430\u043D\u043D\u044B\u0439 store \u043E\u0431\u0435\u0441\u043F\u0435\u0447\u0438\u0442 single source of truth.",
+      Service: "\u0426\u0435\u043D\u0442\u0440\u0430\u043B\u0438\u0437\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \u0441\u0435\u0440\u0432\u0438\u0441 \u0443\u043F\u0440\u043E\u0441\u0442\u0438\u0442 \u0443\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435\u043C \u0438 \u0434\u043E\u0431\u0430\u0432\u0438\u0442 \u043A\u043E\u043D\u0442\u0440\u043E\u043B\u044C \u0434\u043E\u0441\u0442\u0443\u043F\u0430.",
+      Context: "Context API \u043F\u043E\u0434\u043E\u0439\u0434\u0451\u0442 \u0434\u043B\u044F \u043F\u0435\u0440\u0435\u0434\u0430\u0447\u0438 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F \u0447\u0435\u0440\u0435\u0437 \u0434\u0435\u0440\u0435\u0432\u043E \u043A\u043E\u043C\u043F\u043E\u043D\u0435\u043D\u0442\u043E\u0432.",
+      Signal: "Angular Signals \u043E\u0431\u0435\u0441\u043F\u0435\u0447\u0430\u0442 \u0440\u0435\u0430\u043A\u0442\u0438\u0432\u043D\u043E\u0441\u0442\u044C \u0441 \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438\u043C \u043E\u0442\u0441\u043B\u0435\u0436\u0438\u0432\u0430\u043D\u0438\u0435\u043C \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439.",
+      StateManager: "\u041A\u0430\u0441\u0442\u043E\u043C\u043D\u044B\u0439 StateManager \u043F\u043E\u0437\u0432\u043E\u043B\u0438\u0442 \u0440\u0435\u0430\u043B\u0438\u0437\u043E\u0432\u0430\u0442\u044C \u0441\u043F\u0435\u0446\u0438\u0444\u0438\u0447\u043D\u0443\u044E \u043B\u043E\u0433\u0438\u043A\u0443 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u0438.",
+      DI_Lifetime: "Mutable state \u0432 Singleton-\u0441\u0435\u0440\u0432\u0438\u0441\u0435 \u0432\u044B\u0437\u044B\u0432\u0430\u0435\u0442 \u0433\u043E\u043D\u043A\u0438. \u0418\u0437\u043C\u0435\u043D\u0438\u0442\u0435 lifetime \u043D\u0430 Scoped \u0438\u043B\u0438 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 ImmutableDictionary.",
+      Channel: `${raceAnalysis.asyncWriters} async producer/consumer \u043D\u0443\u0436\u0434\u0430\u044E\u0442\u0441\u044F \u0432 \u0443\u043F\u043E\u0440\u044F\u0434\u043E\u0447\u0435\u043D\u043D\u043E\u0439 \u043E\u0431\u0440\u0430\u0431\u043E\u0442\u043A\u0435. System.Threading.Channels \u043E\u0431\u0435\u0441\u043F\u0435\u0447\u0438\u0442 \u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u0443\u044E \u043E\u0447\u0435\u0440\u0435\u0434\u044C.`,
+      ImmutableState: "\u041C\u043D\u043E\u0436\u0435\u0441\u0442\u0432\u043E \u043D\u0435\u043A\u043E\u043D\u0442\u0440\u043E\u043B\u0438\u0440\u0443\u0435\u043C\u044B\u0445 \u043C\u0443\u0442\u0430\u0446\u0438\u0439. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 record types \u0438 ImmutableCollections \u0434\u043B\u044F \u043F\u0440\u0435\u0434\u043E\u0442\u0432\u0440\u0430\u0449\u0435\u043D\u0438\u044F \u0433\u043E\u043D\u043E\u043A."
+    };
+    return reasons[strategy];
+  }
+  /**
+   * Estimate implementation effort
+   */
+  estimateEffort(pattern, raceAnalysis) {
+    const files = new Set(pattern.operations.map((op) => op.file)).size;
+    const conflicts = raceAnalysis.conflicts.length;
+    if (conflicts >= 3 || files > 10) return "\u0412\u044B\u0441\u043E\u043A\u0430\u044F (1-2 \u043D\u0435\u0434\u0435\u043B\u0438)";
+    if (conflicts >= 1 || files > 5) return "\u0421\u0440\u0435\u0434\u043D\u044F\u044F (2-5 \u0434\u043D\u0435\u0439)";
+    return "\u041D\u0438\u0437\u043A\u0430\u044F (1-2 \u0434\u043D\u044F)";
+  }
+  /**
+   * Get emoji for risk level
+   */
+  getRiskEmoji(risk) {
+    const emojis = {
+      none: "\u2705",
+      low: "\u{1F7E2}",
+      medium: "\u{1F7E1}",
+      high: "\u{1F7E0}",
+      critical: "\u{1F534}"
+    };
+    return emojis[risk];
+  }
+};
+
+export { CSHARP_ASYNC_APIS, CSHARP_LOCK_PATTERNS, ChaosAnalyzer, RaceDetector, StateDetector, detectCSharpChaosPatterns, isCSharpStateIdentifier, isStateIdentifier };
+//# sourceMappingURL=chaos-W3XRVJ7K.js.map
+//# sourceMappingURL=chaos-W3XRVJ7K.js.map