@harness-engineering/cli 2.4.5 → 2.6.0

package/dist/chunk-SZEFU6XC.js

@@ -0,0 +1,3337 @@
+import {
+  Err,
+  Ok,
+  init_dist
+} from "./chunk-OH3NXXUY.js";
+import {
+  DEFAULT_SKIP_DIRS,
+  init_dist as init_dist2,
+  skipDirGlobs
+} from "./chunk-BCFDGOMA.js";
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// ../core/dist/chunk-MUWJHO2S.mjs
+import { parse } from "@typescript-eslint/typescript-estree";
+import { access, constants, readFile } from "fs";
+import { promisify } from "util";
+import { relative } from "path";
+import { glob } from "glob";
+import Parser from "web-tree-sitter";
+import { minimatch } from "minimatch";
+import { dirname, resolve, extname } from "path";
+import { readFile as readFile2 } from "fs/promises";
+function createError(code, message, details = {}, suggestions = []) {
+  return { code, message, details, suggestions };
+}
+function createEntropyError(code, message, details = {}, suggestions = []) {
+  return { code, message, details, suggestions };
+}
+function createParseError(code, message, details = {}, suggestions = []) {
+  return { code, message, details, suggestions };
+}
+async function fileExists(path) {
+  try {
+    await accessAsync(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileContent(path) {
+  try {
+    const content = await readFileAsync(path, "utf-8");
+    return Ok(content);
+  } catch (error) {
+    return Err(error);
+  }
+}
+async function findFiles(pattern, cwd = process.cwd(), extraIgnore = []) {
+  return glob(pattern, {
+    cwd,
+    absolute: true,
+    ignore: [...DEFAULT_FIND_FILES_IGNORE, ...extraIgnore]
+  });
+}
+function relativePosix(from, to) {
+  return relative(from, to).replaceAll("\\", "/");
+}
+function walk(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  if ("type" in node) {
+    visitor(node);
+  }
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => walk(v, visitor));
+    } else {
+      walk(value, visitor);
+    }
+  }
+}
+function makeLocation(node) {
+  return {
+    file: "",
+    line: node.loc?.start.line ?? 0,
+    column: node.loc?.start.column ?? 0
+  };
+}
+function processImportSpecifiers(importDecl, imp) {
+  for (const spec of importDecl.specifiers) {
+    if (spec.type === "ImportDefaultSpecifier") {
+      imp.default = spec.local.name;
+    } else if (spec.type === "ImportNamespaceSpecifier") {
+      imp.namespace = spec.local.name;
+    } else if (spec.type === "ImportSpecifier") {
+      imp.specifiers.push(spec.local.name);
+      if (spec.importKind === "type") {
+        imp.kind = "type";
+      }
+    }
+  }
+}
+function getExportedName(exported) {
+  return exported.type === "Identifier" ? exported.name : String(exported.value);
+}
+function processReExportSpecifiers(exportDecl, exports) {
+  for (const spec of exportDecl.specifiers) {
+    if (spec.type !== "ExportSpecifier") continue;
+    exports.push({
+      name: getExportedName(spec.exported),
+      type: "named",
+      location: makeLocation(exportDecl),
+      isReExport: true,
+      source: exportDecl.source.value
+    });
+  }
+}
+function processExportDeclaration(exportDecl, exports) {
+  const decl = exportDecl.declaration;
+  if (!decl) return;
+  if (decl.type === "VariableDeclaration") {
+    for (const declarator of decl.declarations) {
+      if (declarator.id.type === "Identifier") {
+        exports.push({
+          name: declarator.id.name,
+          type: "named",
+          location: makeLocation(decl),
+          isReExport: false
+        });
+      }
+    }
+  } else if ((decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") && decl.id) {
+    exports.push({
+      name: decl.id.name,
+      type: "named",
+      location: makeLocation(decl),
+      isReExport: false
+    });
+  }
+}
+function processExportListSpecifiers(exportDecl, exports) {
+  for (const spec of exportDecl.specifiers) {
+    if (spec.type !== "ExportSpecifier") continue;
+    exports.push({
+      name: getExportedName(spec.exported),
+      type: "named",
+      location: makeLocation(exportDecl),
+      isReExport: false
+    });
+  }
+}
+function detectLanguage(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXTENSION_MAP[ext] ?? null;
+}
+async function ensureInit() {
+  if (!initialized) {
+    await Parser.init();
+    initialized = true;
+  }
+}
+async function resolveWasmPath(grammarName) {
+  const { createRequire } = await import("module");
+  const require2 = createRequire(import.meta.url ?? __filename);
+  const pkgPath = require2.resolve("tree-sitter-wasms/package.json");
+  const path = await import("path");
+  const pkgDir = path.dirname(pkgPath);
+  return path.join(pkgDir, "out", `${grammarName}.wasm`);
+}
+async function loadLanguage(lang) {
+  const grammarName = GRAMMAR_MAP[lang];
+  const wasmPath = await resolveWasmPath(grammarName);
+  return Parser.Language.load(wasmPath);
+}
+async function getParser(lang) {
+  const cached = parserCache.get(lang);
+  if (cached) return cached;
+  await ensureInit();
+  const parser = new Parser();
+  const language = await loadLanguage(lang);
+  parser.setLanguage(language);
+  parserCache.set(lang, parser);
+  return parser;
+}
+async function parseFile(filePath) {
+  const lang = detectLanguage(filePath);
+  if (!lang) {
+    return Err({
+      code: "UNSUPPORTED_LANGUAGE",
+      message: `Unsupported file extension: ${filePath}`
+    });
+  }
+  const contentResult = await readFileContent(filePath);
+  if (!contentResult.ok) {
+    return Err({
+      code: "FILE_NOT_FOUND",
+      message: `Cannot read file: ${filePath}`
+    });
+  }
+  try {
+    const parser = await getParser(lang);
+    const tree = parser.parse(contentResult.value);
+    return Ok({ tree, language: lang, source: contentResult.value, filePath });
+  } catch (e) {
+    return Err({
+      code: "PARSE_FAILED",
+      message: `Tree-sitter parse failed for ${filePath}: ${e.message}`
+    });
+  }
+}
+function resetParserCache() {
+  parserCache.clear();
+  initialized = false;
+}
+function findIdentifier(node) {
+  return node.childForFieldName("name") ?? node.children.find((c) => IDENTIFIER_TYPES.has(c.type)) ?? null;
+}
+function getVariableDeclarationName(node) {
+  const declarator = node.children.find((c) => c.type === "variable_declarator");
+  if (!declarator) return null;
+  const id = findIdentifier(declarator);
+  return id?.text ?? null;
+}
+function getExportName(node, source) {
+  const decl = node.children.find(
+    (c) => c.type !== "export" && c.type !== "default" && c.type !== "comment"
+  );
+  return decl ? getNodeName(decl, source) : "<anonymous>";
+}
+function getAssignmentName(node) {
+  const left = node.childForFieldName("left") ?? node.children[0];
+  return left?.text ?? "<anonymous>";
+}
+function getGoTypeSpecName(node) {
+  const typeSpec = node.children.find((c) => c.type === "type_spec");
+  if (typeSpec) {
+    const id = findIdentifier(typeSpec);
+    if (id) return id.text;
+  }
+  return "<anonymous>";
+}
+function getRustImplName(node) {
+  const typeId = node.childForFieldName("type");
+  if (typeId) return typeId.text;
+  const id = node.children.find((c) => IDENTIFIER_TYPES.has(c.type));
+  return id?.text ?? "<anonymous>";
+}
+function getGoVarName(node) {
+  const spec = node.children.find((c) => c.type === "var_spec" || c.type === "const_spec");
+  if (spec) {
+    const id = findIdentifier(spec);
+    if (id) return id.text;
+  }
+  return "<anonymous>";
+}
+function getNodeName(node, source) {
+  const id = findIdentifier(node);
+  if (id) return id.text;
+  const extractor = NAME_EXTRACTORS[node.type];
+  if (extractor) return extractor(node, source) ?? "<anonymous>";
+  return "<anonymous>";
+}
+function getSignature(node, source) {
+  const startLine = node.startPosition.row;
+  const lines = source.split("\n");
+  return (lines[startLine] ?? "").trim();
+}
+function extractMethods(classNode, language, source, filePath) {
+  const methodTypes = METHOD_TYPES[language] ?? [];
+  const body = classNode.childForFieldName("body") ?? classNode.children.find(
+    (c) => c.type === "class_body" || c.type === "block" || c.type === "declaration_list" || c.type === "field_declaration_list"
+  );
+  if (!body) return [];
+  return body.children.filter((child) => methodTypes.includes(child.type)).map((child) => ({
+    name: getNodeName(child, source),
+    kind: "method",
+    file: filePath,
+    line: child.startPosition.row + 1,
+    endLine: child.endPosition.row + 1,
+    signature: getSignature(child, source)
+  }));
+}
+function nodeToSymbol(node, kind, source, filePath) {
+  return {
+    name: getNodeName(node, source),
+    kind,
+    file: filePath,
+    line: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature: getSignature(node, source)
+  };
+}
+function processExportStatement(child, topLevelTypes, lang, source, filePath) {
+  const declaration = child.children.find(
+    (c) => c.type !== "export" && c.type !== "default" && c.type !== ";" && c.type !== "comment"
+  );
+  const kind = declaration ? topLevelTypes[declaration.type] : void 0;
+  if (declaration && kind) {
+    const sym = nodeToSymbol(child, kind, source, filePath);
+    sym.name = getNodeName(declaration, source);
+    if (kind === "class") {
+      sym.children = extractMethods(declaration, lang, source, filePath);
+    }
+    return sym;
+  }
+  return nodeToSymbol(child, "export", source, filePath);
+}
+function extractSymbols(rootNode, lang, source, filePath) {
+  const symbols = [];
+  const topLevelTypes = TOP_LEVEL_TYPES[lang] ?? {};
+  for (const child of rootNode.children) {
+    if (child.type === "export_statement") {
+      symbols.push(processExportStatement(child, topLevelTypes, lang, source, filePath));
+      continue;
+    }
+    const kind = topLevelTypes[child.type];
+    if (!kind || kind === "import") continue;
+    const sym = nodeToSymbol(child, kind, source, filePath);
+    if (kind === "class") {
+      sym.children = extractMethods(child, lang, source, filePath);
+    }
+    symbols.push(sym);
+  }
+  return symbols;
+}
+function buildFailedResult(filePath, lang) {
+  return { file: filePath, language: lang, totalLines: 0, symbols: [], error: "[parse-failed]" };
+}
+function extractOutlineFromTree(rootNode, lang, source, filePath) {
+  const totalLines = source.split("\n").length;
+  const symbols = extractSymbols(rootNode, lang, source, filePath);
+  return { file: filePath, language: lang, totalLines, symbols };
+}
+async function getOutline(filePath) {
+  const lang = detectLanguage(filePath);
+  if (!lang) return buildFailedResult(filePath, "unknown");
+  const result = await parseFile(filePath);
+  if (!result.ok) return buildFailedResult(filePath, lang);
+  const { tree, source } = result.value;
+  const totalLines = source.split("\n").length;
+  const symbols = extractSymbols(tree.rootNode, lang, source, filePath);
+  return { file: filePath, language: lang, totalLines, symbols };
+}
+function formatOutline(outline) {
+  if (outline.error) {
+    return `${outline.file} ${outline.error}`;
+  }
+  const lines = [`${outline.file} (${outline.totalLines} lines)`];
+  const last = outline.symbols.length - 1;
+  outline.symbols.forEach((sym, i) => {
+    const prefix = i === last ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+    lines.push(`${prefix} ${sym.signature}    :${sym.line}`);
+    if (sym.children) {
+      const childLast = sym.children.length - 1;
+      sym.children.forEach((child, j) => {
+        const childConnector = i === last ? "    " : "\u2502   ";
+        const childPrefix = j === childLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        lines.push(`${childConnector}${childPrefix} ${child.signature}    :${child.line}`);
+      });
+    }
+  });
+  return lines.join("\n");
+}
+function defineLayer(name, patterns, allowedDependencies) {
+  return {
+    name,
+    patterns,
+    allowedDependencies
+  };
+}
+function resolveFileToLayer(file, layers) {
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      if (minimatch(file, pattern)) {
+        return layer;
+      }
+    }
+  }
+  return void 0;
+}
+function detectLangFromExt(ext) {
+  for (const [lang, exts] of Object.entries(EXTENSION_BY_LANG)) {
+    if (exts.includes(ext)) return lang;
+  }
+  return null;
+}
+function getExtensionsForLang(lang) {
+  switch (lang) {
+    case "typescript":
+      return [".ts", ".tsx"];
+    case "javascript":
+      return [".js", ".jsx", ".mjs", ".cjs"];
+    case "python":
+      return [".py"];
+    case "go":
+      return [".go"];
+    case "rust":
+      return [".rs"];
+    case "java":
+      return [".java"];
+    default:
+      return [".ts", ".tsx", ".js", ".jsx"];
+  }
+}
+async function resolveImportPath(importSource, fromFile, _rootDir) {
+  if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
+    return null;
+  }
+  const fromDir = dirname(fromFile);
+  const resolved = resolve(fromDir, importSource);
+  const sourceExt = extname(resolved);
+  const fromLang = detectLangFromExt(extname(fromFile));
+  const fallbacks = JS_EXT_FALLBACKS[sourceExt];
+  if (fallbacks) {
+    const base = resolved.slice(0, -sourceExt.length);
+    for (const ext of fallbacks) {
+      const candidate = base + ext;
+      if (await fileExists(candidate)) return candidate.replace(/\\/g, "/");
+    }
+    for (const indexExt of [".ts", ".tsx", ".jsx"]) {
+      const indexPath = resolve(base, "index" + indexExt);
+      if (await fileExists(indexPath)) return indexPath.replace(/\\/g, "/");
+    }
+  }
+  const hasKnownExt = Object.values(EXTENSION_BY_LANG).flat().some((e) => resolved.endsWith(e));
+  if (hasKnownExt) {
+    return resolved.replace(/\\/g, "/");
+  }
+  const extensions = getExtensionsForLang(fromLang);
+  return (resolved + extensions[0]).replace(/\\/g, "/");
+}
+function getImportType(imp) {
+  if (imp.kind === "type") return "type-only";
+  return "static";
+}
+async function buildDependencyGraph(files, parser, graphDependencyData) {
+  if (graphDependencyData) {
+    return Ok({
+      nodes: graphDependencyData.nodes,
+      edges: graphDependencyData.edges
+    });
+  }
+  const isLookup = "getForFile" in parser;
+  const nodes = files.map((f) => f.replace(/\\/g, "/"));
+  const edges = [];
+  for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
+    const fileParser = isLookup ? parser.getForFile(file) : parser;
+    if (!fileParser) continue;
+    const parseResult = await fileParser.parseFile(file);
+    if (!parseResult.ok) {
+      continue;
+    }
+    const importsResult = fileParser.extractImports(parseResult.value);
+    if (!importsResult.ok) {
+      continue;
+    }
+    for (const imp of importsResult.value) {
+      const resolvedPath = await resolveImportPath(imp.source, file, "");
+      if (resolvedPath) {
+        edges.push({
+          from: normalizedFile,
+          to: resolvedPath,
+          importType: getImportType(imp),
+          line: imp.location.line
+        });
+      }
+    }
+  }
+  return Ok({ nodes, edges });
+}
+function checkLayerViolations(graph, layers, rootDir) {
+  const violations = [];
+  for (const edge of graph.edges) {
+    const fromRelative = relativePosix(rootDir, edge.from);
+    const toRelative = relativePosix(rootDir, edge.to);
+    const fromLayer = resolveFileToLayer(fromRelative, layers);
+    const toLayer = resolveFileToLayer(toRelative, layers);
+    if (!fromLayer || !toLayer) continue;
+    if (fromLayer.name === toLayer.name) continue;
+    if (!fromLayer.allowedDependencies.includes(toLayer.name)) {
+      violations.push({
+        file: edge.from,
+        imports: edge.to,
+        fromLayer: fromLayer.name,
+        toLayer: toLayer.name,
+        reason: "WRONG_LAYER",
+        line: edge.line,
+        suggestion: `Move the dependency to an allowed layer (${fromLayer.allowedDependencies.join(", ") || "none"}) or update layer rules`
+      });
+    }
+  }
+  return violations;
+}
+async function validateDependencies(config) {
+  const { layers, rootDir, parser, fallbackBehavior = "error", graphDependencyData } = config;
+  if (graphDependencyData) {
+    const graphResult2 = await buildDependencyGraph([], parser, graphDependencyData);
+    if (!graphResult2.ok) {
+      return Err(graphResult2.error);
+    }
+    const violations2 = checkLayerViolations(graphResult2.value, layers, rootDir);
+    return Ok({
+      valid: violations2.length === 0,
+      violations: violations2,
+      graph: graphResult2.value
+    });
+  }
+  const healthResult = await parser.health();
+  if (!healthResult.ok || !healthResult.value.available) {
+    if (fallbackBehavior === "skip") {
+      return Ok({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
+      });
+    }
+    if (fallbackBehavior === "warn") {
+      console.warn(`Parser ${parser.name} unavailable, skipping validation`);
+      return Ok({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
+      });
+    }
+    return Err(
+      createError(
+        "PARSER_UNAVAILABLE",
+        `Parser ${parser.name} is not available`,
+        { parser: parser.name },
+        ["Install required runtime", "Use different parser", 'Set fallbackBehavior: "skip"']
+      )
+    );
+  }
+  const allFiles = [];
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      const files = await findFiles(pattern, rootDir);
+      allFiles.push(...files);
+    }
+  }
+  const uniqueFiles = [...new Set(allFiles)];
+  const graphResult = await buildDependencyGraph(uniqueFiles, parser);
+  if (!graphResult.ok) {
+    return Err(graphResult.error);
+  }
+  const violations = checkLayerViolations(graphResult.value, layers, rootDir);
+  return Ok({
+    valid: violations.length === 0,
+    violations,
+    graph: graphResult.value
+  });
+}
+function extractFunctions(content) {
+  const functions = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of FUNCTION_PATTERNS) {
+      const match = line.match(pattern);
+      if (match) {
+        const name = match[1] ?? "anonymous";
+        const paramsStr = match[2] || "";
+        const params = paramsStr.trim() === "" ? 0 : paramsStr.split(",").length;
+        const endLine = findFunctionEnd(lines, i);
+        const body = lines.slice(i, endLine + 1).join("\n");
+        functions.push({
+          name,
+          line: i + 1,
+          params,
+          startLine: i + 1,
+          endLine: endLine + 1,
+          body
+        });
+        break;
+      }
+    }
+  }
+  return functions;
+}
+function findFunctionEnd(lines, startIdx) {
+  let depth = 0;
+  let foundOpen = false;
+  for (let i = startIdx; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}") {
+        depth--;
+        if (foundOpen && depth === 0) {
+          return i;
+        }
+      }
+    }
+  }
+  return lines.length - 1;
+}
+function countDecisionPoints(body) {
+  let count = 0;
+  for (const pattern of DECISION_PATTERNS) {
+    const matches = body.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function computeCyclomaticComplexity(body) {
+  let complexity = 1 + countDecisionPoints(body);
+  const elseIfMatches = body.match(/\belse\s+if\s*\(/g);
+  if (elseIfMatches) {
+    complexity -= elseIfMatches.length;
+  }
+  return complexity;
+}
+function computeNestingDepth(body) {
+  let maxDepth = 0;
+  let currentDepth = 0;
+  let functionBodyStarted = false;
+  for (const ch of body) {
+    if (ch === "{") {
+      if (!functionBodyStarted) {
+        functionBodyStarted = true;
+        continue;
+      }
+      currentDepth++;
+      if (currentDepth > maxDepth) {
+        maxDepth = currentDepth;
+      }
+    } else if (ch === "}") {
+      if (currentDepth > 0) {
+        currentDepth--;
+      }
+    }
+  }
+  return maxDepth;
+}
+function resolveThresholds(config) {
+  const userThresholds = config?.thresholds;
+  if (!userThresholds) return { ...DEFAULT_THRESHOLDS };
+  return {
+    cyclomaticComplexity: {
+      ...DEFAULT_THRESHOLDS.cyclomaticComplexity,
+      ...stripUndefined(userThresholds.cyclomaticComplexity)
+    },
+    nestingDepth: {
+      ...DEFAULT_THRESHOLDS.nestingDepth,
+      ...stripUndefined(userThresholds.nestingDepth)
+    },
+    functionLength: {
+      ...DEFAULT_THRESHOLDS.functionLength,
+      ...stripUndefined(userThresholds.functionLength)
+    },
+    parameterCount: {
+      ...DEFAULT_THRESHOLDS.parameterCount,
+      ...stripUndefined(userThresholds.parameterCount)
+    },
+    fileLength: { ...DEFAULT_THRESHOLDS.fileLength, ...stripUndefined(userThresholds.fileLength) }
+  };
+}
+function stripUndefined(obj) {
+  if (!obj) return {};
+  const result = {};
+  for (const [key, val] of Object.entries(obj)) {
+    if (val !== void 0) result[key] = val;
+  }
+  return result;
+}
+function checkFileLengthViolation(filePath, lineCount, threshold) {
+  if (lineCount <= threshold) return null;
+  return {
+    file: filePath,
+    function: "<file>",
+    line: 1,
+    metric: "fileLength",
+    value: lineCount,
+    threshold,
+    tier: 3,
+    severity: "info",
+    message: `File has ${lineCount} lines (threshold: ${threshold})`
+  };
+}
+function checkCyclomaticComplexity(filePath, fn, thresholds) {
+  const complexity = computeCyclomaticComplexity(fn.body);
+  if (complexity > thresholds.error) {
+    return {
+      file: filePath,
+      function: fn.name,
+      line: fn.line,
+      metric: "cyclomaticComplexity",
+      value: complexity,
+      threshold: thresholds.error,
+      tier: 1,
+      severity: "error",
+      message: `Function "${fn.name}" has cyclomatic complexity of ${complexity} (error threshold: ${thresholds.error})`
+    };
+  }
+  if (complexity > thresholds.warn) {
+    return {
+      file: filePath,
+      function: fn.name,
+      line: fn.line,
+      metric: "cyclomaticComplexity",
+      value: complexity,
+      threshold: thresholds.warn,
+      tier: 2,
+      severity: "warning",
+      message: `Function "${fn.name}" has cyclomatic complexity of ${complexity} (warning threshold: ${thresholds.warn})`
+    };
+  }
+  return null;
+}
+function checkNestingDepth(filePath, fn, threshold) {
+  const depth = computeNestingDepth(fn.body);
+  if (depth <= threshold) return null;
+  return {
+    file: filePath,
+    function: fn.name,
+    line: fn.line,
+    metric: "nestingDepth",
+    value: depth,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Function "${fn.name}" has nesting depth of ${depth} (threshold: ${threshold})`
+  };
+}
+function checkFunctionLength(filePath, fn, threshold) {
+  const fnLength = fn.endLine - fn.startLine + 1;
+  if (fnLength <= threshold) return null;
+  return {
+    file: filePath,
+    function: fn.name,
+    line: fn.line,
+    metric: "functionLength",
+    value: fnLength,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Function "${fn.name}" is ${fnLength} lines long (threshold: ${threshold})`
+  };
+}
+function checkParameterCount(filePath, fn, threshold) {
+  if (fn.params <= threshold) return null;
+  return {
+    file: filePath,
+    function: fn.name,
+    line: fn.line,
+    metric: "parameterCount",
+    value: fn.params,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Function "${fn.name}" has ${fn.params} parameters (threshold: ${threshold})`
+  };
+}
+function checkHotspot(filePath, fn, graphData) {
+  const hotspot = graphData.hotspots.find((h) => h.file === filePath && h.function === fn.name);
+  if (!hotspot || hotspot.hotspotScore <= graphData.percentile95Score) return null;
+  return {
+    file: filePath,
+    function: fn.name,
+    line: fn.line,
+    metric: "hotspotScore",
+    value: hotspot.hotspotScore,
+    threshold: graphData.percentile95Score,
+    tier: 1,
+    severity: "error",
+    message: `Function "${fn.name}" is a complexity hotspot (score: ${hotspot.hotspotScore}, p95: ${graphData.percentile95Score})`
+  };
+}
+function collectFunctionViolations(filePath, fn, thresholds, graphData) {
+  const checks = [
+    checkCyclomaticComplexity(filePath, fn, thresholds.cyclomaticComplexity),
+    checkNestingDepth(filePath, fn, thresholds.nestingDepth.warn),
+    checkFunctionLength(filePath, fn, thresholds.functionLength.warn),
+    checkParameterCount(filePath, fn, thresholds.parameterCount.warn)
+  ];
+  if (graphData) {
+    checks.push(checkHotspot(filePath, fn, graphData));
+  }
+  return checks.filter((v) => v !== null);
+}
+async function detectComplexityViolations(snapshot, config, graphData) {
+  const violations = [];
+  const thresholds = resolveThresholds(config);
+  let totalFunctions = 0;
+  for (const file of snapshot.files) {
+    let content;
+    try {
+      content = await readFile2(file.path, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    const fileLenViolation = checkFileLengthViolation(
+      file.path,
+      lines.length,
+      thresholds.fileLength.info
+    );
+    if (fileLenViolation) violations.push(fileLenViolation);
+    const functions = extractFunctions(content);
+    totalFunctions += functions.length;
+    for (const fn of functions) {
+      violations.push(...collectFunctionViolations(file.path, fn, thresholds, graphData));
+    }
+  }
+  const errorCount = violations.filter((v) => v.severity === "error").length;
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const infoCount = violations.filter((v) => v.severity === "info").length;
+  return Ok({
+    violations,
+    stats: {
+      filesAnalyzed: snapshot.files.length,
+      functionsAnalyzed: totalFunctions,
+      violationCount: violations.length,
+      errorCount,
+      warningCount,
+      infoCount
+    }
+  });
+}
+function computeMetricsFromSnapshot(snapshot) {
+  const fanInMap = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const resolved = resolveImportSource(imp.source, file.path, snapshot);
+      if (resolved) {
+        fanInMap.set(resolved, (fanInMap.get(resolved) || 0) + 1);
+      }
+    }
+  }
+  return snapshot.files.map((file) => {
+    const fanOut = file.imports.length;
+    const fanIn = fanInMap.get(file.path) || 0;
+    const total = fanIn + fanOut;
+    const couplingRatio = total > 0 ? fanOut / total : 0;
+    return {
+      file: file.path,
+      fanIn,
+      fanOut,
+      couplingRatio,
+      transitiveDepth: 0
+    };
+  });
+}
+function resolveRelativePath(from, source) {
+  const dir = from.includes("/") ? from.substring(0, from.lastIndexOf("/")) : ".";
+  const parts = dir.split("/");
+  for (const segment of source.split("/")) {
+    if (segment === ".") continue;
+    if (segment === "..") {
+      parts.pop();
+    } else {
+      parts.push(segment);
+    }
+  }
+  return parts.join("/");
+}
+function resolveImportSource(source, fromFile, snapshot) {
+  if (!source.startsWith(".") && !source.startsWith("/")) {
+    return void 0;
+  }
+  const resolved = resolveRelativePath(fromFile, source);
+  const filePaths = snapshot.files.map((f) => f.path);
+  const candidates = [
+    resolved,
+    `${resolved}.ts`,
+    `${resolved}.tsx`,
+    `${resolved}/index.ts`,
+    `${resolved}/index.tsx`
+  ];
+  for (const candidate of candidates) {
+    const match = filePaths.find((fp) => fp === candidate);
+    if (match) return match;
+  }
+  return void 0;
+}
+function resolveThresholds2(config) {
+  return {
+    fanOut: { ...DEFAULT_THRESHOLDS2.fanOut, ...config?.thresholds?.fanOut },
+    fanIn: { ...DEFAULT_THRESHOLDS2.fanIn, ...config?.thresholds?.fanIn },
+    couplingRatio: { ...DEFAULT_THRESHOLDS2.couplingRatio, ...config?.thresholds?.couplingRatio },
+    transitiveDependencyDepth: {
+      ...DEFAULT_THRESHOLDS2.transitiveDependencyDepth,
+      ...config?.thresholds?.transitiveDependencyDepth
+    }
+  };
+}
+function checkFanOut(m, threshold) {
+  if (m.fanOut <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "fanOut",
+    value: m.fanOut,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `File has ${m.fanOut} imports (threshold: ${threshold})`
+  };
+}
+function checkFanIn(m, threshold) {
+  if (m.fanIn <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "fanIn",
+    value: m.fanIn,
+    threshold,
+    tier: 3,
+    severity: "info",
+    message: `File is imported by ${m.fanIn} files (threshold: ${threshold})`
+  };
+}
+function checkCouplingRatio(m, threshold) {
+  const totalConnections = m.fanIn + m.fanOut;
+  if (totalConnections <= 5 || m.couplingRatio <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "couplingRatio",
+    value: m.couplingRatio,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Coupling ratio is ${m.couplingRatio.toFixed(2)} (threshold: ${threshold})`
+  };
+}
+function checkTransitiveDepth(m, threshold) {
+  if (m.transitiveDepth <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "transitiveDependencyDepth",
+    value: m.transitiveDepth,
+    threshold,
+    tier: 3,
+    severity: "info",
+    message: `Transitive dependency depth is ${m.transitiveDepth} (threshold: ${threshold})`
+  };
+}
+function checkMetricViolations(m, thresholds) {
+  const candidates = [
+    checkFanOut(m, thresholds.fanOut.warn),
+    checkFanIn(m, thresholds.fanIn.info),
+    checkCouplingRatio(m, thresholds.couplingRatio.warn),
+    checkTransitiveDepth(m, thresholds.transitiveDependencyDepth.info)
+  ];
+  return candidates.filter((v) => v !== null);
+}
+function checkViolations(metrics, config) {
+  const thresholds = resolveThresholds2(config);
+  const violations = [];
+  for (const m of metrics) {
+    violations.push(...checkMetricViolations(m, thresholds));
+  }
+  return violations;
+}
+async function detectCouplingViolations(snapshot, config, graphData) {
+  let metrics;
+  if (graphData) {
+    metrics = graphData.files.map((f) => ({
+      file: f.file,
+      fanIn: f.fanIn,
+      fanOut: f.fanOut,
+      couplingRatio: f.couplingRatio,
+      transitiveDepth: f.transitiveDepth
+    }));
+  } else {
+    metrics = computeMetricsFromSnapshot(snapshot);
+  }
+  const violations = checkViolations(metrics, config);
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const infoCount = violations.filter((v) => v.severity === "info").length;
+  return Ok({
+    violations,
+    stats: {
+      filesAnalyzed: metrics.length,
+      violationCount: violations.length,
+      warningCount,
+      infoCount
+    }
+  });
+}
+function findSymbolByName(symbols, name) {
+  for (const sym of symbols) {
+    if (sym.name === name) return { line: sym.line, endLine: sym.endLine };
+    if (sym.children) {
+      const found = findSymbolByName(sym.children, name);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function makeLocation2(node) {
+  return {
+    file: "",
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column
+  };
+}
+function makeNamedExport(node) {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return { name: name.text, type: "named", location: makeLocation2(node), isReExport: false };
+}
+function makeImport(node, source) {
+  return { source, specifiers: [], location: makeLocation2(node), kind: "value" };
+}
+function extractPythonImport(child) {
+  const name = child.childForFieldName("name");
+  if (!name) return null;
+  return makeImport(child, name.text);
+}
+function extractPythonFromImport(child) {
+  const moduleName = child.childForFieldName("module_name");
+  const specifiers = [];
+  for (const c of child.children) {
+    if (c.type === "dotted_name" && c !== moduleName) specifiers.push(c.text);
+    if (c.type === "aliased_import") {
+      const n = c.childForFieldName("name");
+      if (n) specifiers.push(n.text);
+    }
+  }
+  return {
+    source: moduleName?.text ?? "",
+    specifiers,
+    location: makeLocation2(child),
+    kind: "value"
+  };
+}
+function extractPythonExport(child) {
+  if (child.type === "function_definition" || child.type === "class_definition") {
+    return makeNamedExport(child);
+  }
+  if (child.type === "assignment") {
+    const left = child.childForFieldName("left") ?? child.children[0];
+    if (left && !left.text.startsWith("_")) {
+      return { name: left.text, type: "named", location: makeLocation2(child), isReExport: false };
+    }
+  }
+  return null;
+}
+function extractGoImportPath(spec) {
+  const pathNode = spec.childForFieldName("path") ?? spec.children.find((c) => c.type === "interpreted_string_literal");
+  return pathNode ? pathNode.text.replace(/"/g, "") : null;
+}
+function extractGoImportsFromDecl(child) {
+  const imports = [];
+  for (const spec of child.children.filter((c) => c.type === "import_spec")) {
+    const source = extractGoImportPath(spec);
+    if (source) imports.push(makeImport(child, source));
+  }
+  const specList = child.children.find((c) => c.type === "import_spec_list");
+  if (specList) {
+    for (const spec of specList.children.filter((c) => c.type === "import_spec")) {
+      const source = extractGoImportPath(spec);
+      if (source) imports.push(makeImport(spec, source));
+    }
+  }
+  return imports;
+}
+function isGoExported(name) {
+  return /^[A-Z]/.test(name);
+}
+function extractGoExport(child) {
+  if (child.type === "function_declaration" || child.type === "method_declaration") {
+    const name = child.childForFieldName("name");
+    if (name && isGoExported(name.text)) return makeNamedExport(child);
+  }
+  if (child.type === "type_declaration") {
+    const typeSpec = child.children.find((c) => c.type === "type_spec");
+    if (typeSpec) {
+      const name = typeSpec.childForFieldName("name");
+      if (name && isGoExported(name.text)) {
+        return { name: name.text, type: "named", location: makeLocation2(child), isReExport: false };
+      }
+    }
+  }
+  return null;
+}
+function createTreeSitterParser(lang) {
+  const strategy = STRATEGIES[lang];
+  if (!strategy) return null;
+  const extensionMap = {
+    python: [".py"],
+    go: [".go"],
+    rust: [".rs"],
+    java: [".java"]
+  };
+  const extensions = extensionMap[lang];
+  if (!extensions) return null;
+  return new TreeSitterParser(lang, extensions, strategy);
+}
+function getDefaultRegistry() {
+  if (defaultRegistry) return defaultRegistry;
+  const registry = new ParserRegistry();
+  const tsParser = new TypeScriptParser();
+  registry.register(tsParser);
+  registry.register({
+    name: "javascript",
+    extensions: [".js", ".jsx", ".mjs", ".cjs"],
+    parseFile: tsParser.parseFile.bind(tsParser),
+    extractImports: tsParser.extractImports.bind(tsParser),
+    extractExports: tsParser.extractExports.bind(tsParser),
+    health: tsParser.health.bind(tsParser)
+  });
+  const treeSitterLanguages = ["python", "go", "rust", "java"];
+  for (const lang of treeSitterLanguages) {
+    const parser = createTreeSitterParser(lang);
+    if (parser) {
+      registry.register(parser);
+    }
+  }
+  defaultRegistry = registry;
+  return registry;
+}
+var accessAsync, readFileAsync, DEFAULT_FIND_FILES_IGNORE, TypeScriptParser, EXTENSION_MAP, parserCache, initialized, GRAMMAR_MAP, TOP_LEVEL_TYPES, METHOD_TYPES, IDENTIFIER_TYPES, NAME_EXTRACTORS, EXTENSION_BY_LANG, JS_EXT_FALLBACKS, DEFAULT_THRESHOLDS, FUNCTION_PATTERNS, DECISION_PATTERNS, DEFAULT_THRESHOLDS2, pythonStrategy, goStrategy, RUST_USE_ARG_TYPES, RUST_PUB_ITEM_TYPES, rustStrategy, JAVA_IMPORT_TYPES, JAVA_EXPORT_TYPES, javaStrategy, STRATEGIES, TreeSitterParser, ParserRegistry, defaultRegistry;
+var init_chunk_MUWJHO2S = __esm({
+  "../core/dist/chunk-MUWJHO2S.mjs"() {
+    "use strict";
+    init_dist();
+    accessAsync = promisify(access);
+    readFileAsync = promisify(readFile);
+    DEFAULT_FIND_FILES_IGNORE = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**"
+    ];
+    TypeScriptParser = class {
+      name = "typescript";
+      extensions = [".ts", ".tsx", ".mts", ".cts"];
+      async parseFile(path) {
+        const contentResult = await readFileContent(path);
+        if (!contentResult.ok) {
+          return Err(
+            createParseError("NOT_FOUND", `File not found: ${path}`, { path }, [
+              "Check that the file exists",
+              "Verify the path is correct"
+            ])
+          );
+        }
+        try {
+          const ast = parse(contentResult.value, {
+            loc: true,
+            range: true,
+            jsx: path.endsWith(".tsx"),
+            errorOnUnknownASTType: false
+          });
+          return Ok({
+            type: "Program",
+            body: ast,
+            language: "typescript"
+          });
+        } catch (e) {
+          const error = e;
+          return Err(
+            createParseError("SYNTAX_ERROR", `Failed to parse ${path}: ${error.message}`, { path }, [
+              "Check for syntax errors in the file",
+              "Ensure valid TypeScript syntax"
+            ])
+          );
+        }
+      }
+      extractImports(ast) {
+        const imports = [];
+        const program = ast.body;
+        walk(program, (node) => {
+          if (node.type === "ImportDeclaration") {
+            const importDecl = node;
+            const imp = {
+              source: importDecl.source.value,
+              specifiers: [],
+              location: makeLocation(importDecl),
+              kind: importDecl.importKind === "type" ? "type" : "value"
+            };
+            processImportSpecifiers(importDecl, imp);
+            imports.push(imp);
+            return;
+          }
+          if (node.type === "ImportExpression") {
+            const importExpr = node;
+            if (importExpr.source.type === "Literal" && typeof importExpr.source.value === "string") {
+              imports.push({
+                source: importExpr.source.value,
+                specifiers: [],
+                location: makeLocation(importExpr),
+                kind: "value"
+              });
+            }
+          }
+        });
+        return Ok(imports);
+      }
+      extractExports(ast) {
+        const exports = [];
+        const program = ast.body;
+        walk(program, (node) => {
+          if (node.type === "ExportNamedDeclaration") {
+            const exportDecl = node;
+            if (exportDecl.source) {
+              processReExportSpecifiers(exportDecl, exports);
+              return;
+            }
+            processExportDeclaration(exportDecl, exports);
+            processExportListSpecifiers(exportDecl, exports);
+            return;
+          }
+          if (node.type === "ExportDefaultDeclaration") {
+            const exportDecl = node;
+            exports.push({
+              name: "default",
+              type: "default",
+              location: makeLocation(exportDecl),
+              isReExport: false
+            });
+            return;
+          }
+          if (node.type === "ExportAllDeclaration") {
+            const exportDecl = node;
+            exports.push({
+              name: exportDecl.exported?.name ?? "*",
+              type: "namespace",
+              location: makeLocation(exportDecl),
+              isReExport: true,
+              source: exportDecl.source.value
+            });
+          }
+        });
+        return Ok(exports);
+      }
+      async health() {
+        return Ok({ available: true, version: "7.0.0" });
+      }
+    };
+    EXTENSION_MAP = {
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".mts": "typescript",
+      ".cts": "typescript",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java"
+    };
+    parserCache = /* @__PURE__ */ new Map();
+    initialized = false;
+    GRAMMAR_MAP = {
+      typescript: "tree-sitter-typescript",
+      javascript: "tree-sitter-javascript",
+      python: "tree-sitter-python",
+      go: "tree-sitter-go",
+      rust: "tree-sitter-rust",
+      java: "tree-sitter-java"
+    };
+    TOP_LEVEL_TYPES = {
+      typescript: {
+        function_declaration: "function",
+        class_declaration: "class",
+        interface_declaration: "interface",
+        type_alias_declaration: "type",
+        lexical_declaration: "variable",
+        variable_declaration: "variable",
+        export_statement: "export",
+        import_statement: "import",
+        enum_declaration: "type"
+      },
+      javascript: {
+        function_declaration: "function",
+        class_declaration: "class",
+        lexical_declaration: "variable",
+        variable_declaration: "variable",
+        export_statement: "export",
+        import_statement: "import"
+      },
+      python: {
+        function_definition: "function",
+        class_definition: "class",
+        assignment: "variable",
+        import_statement: "import",
+        import_from_statement: "import"
+      },
+      go: {
+        function_declaration: "function",
+        method_declaration: "method",
+        type_declaration: "type",
+        var_declaration: "variable",
+        const_declaration: "variable",
+        import_declaration: "import",
+        short_var_declaration: "variable"
+      },
+      rust: {
+        function_item: "function",
+        struct_item: "class",
+        enum_item: "type",
+        trait_item: "interface",
+        impl_item: "class",
+        mod_item: "variable",
+        const_item: "variable",
+        static_item: "variable",
+        type_item: "type",
+        use_declaration: "import"
+      },
+      java: {
+        class_declaration: "class",
+        interface_declaration: "interface",
+        method_declaration: "function",
+        field_declaration: "variable",
+        import_declaration: "import",
+        enum_declaration: "type",
+        record_declaration: "class",
+        annotation_type_declaration: "interface"
+      }
+    };
+    METHOD_TYPES = {
+      typescript: ["method_definition", "public_field_definition"],
+      javascript: ["method_definition"],
+      python: ["function_definition"],
+      go: ["method_declaration"],
+      rust: ["function_item"],
+      java: ["method_declaration", "constructor_declaration"]
+    };
+    IDENTIFIER_TYPES = /* @__PURE__ */ new Set(["identifier", "property_identifier", "type_identifier"]);
+    NAME_EXTRACTORS = {
+      lexical_declaration: (n) => getVariableDeclarationName(n),
+      variable_declaration: (n) => getVariableDeclarationName(n),
+      export_statement: (n, s) => getExportName(n, s),
+      assignment: (n) => getAssignmentName(n),
+      type_declaration: (n) => getGoTypeSpecName(n),
+      impl_item: (n) => getRustImplName(n),
+      var_declaration: (n) => getGoVarName(n),
+      const_declaration: (n) => getGoVarName(n)
+    };
+    EXTENSION_BY_LANG = {
+      typescript: [".ts", ".tsx"],
+      javascript: [".js", ".jsx", ".mjs", ".cjs"],
+      python: [".py"],
+      go: [".go"],
+      rust: [".rs"],
+      java: [".java"]
+    };
+    JS_EXT_FALLBACKS = {
+      ".js": [".ts", ".tsx", ".jsx"],
+      ".jsx": [".tsx"],
+      ".mjs": [".mts"],
+      ".cjs": [".cts"]
+    };
+    DEFAULT_THRESHOLDS = {
+      cyclomaticComplexity: { error: 15, warn: 10 },
+      nestingDepth: { warn: 4 },
+      functionLength: { warn: 50 },
+      parameterCount: { warn: 5 },
+      fileLength: { info: 300 },
+      hotspotPercentile: { error: 95 }
+    };
+    FUNCTION_PATTERNS = [
+      // function declarations: function name(params) {
+      /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
+      // method declarations: name(params) {
+      /^\s*(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*[^{]+)?\s*\{/,
+      // arrow functions assigned to const/let/var: const name = (params) =>
+      /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/,
+      // arrow functions assigned to const/let/var with single param: const name = param =>
+      /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(\w+)\s*=>/
+    ];
+    DECISION_PATTERNS = [
+      /\bif\s*\(/g,
+      /\belse\s+if\s*\(/g,
+      /\bwhile\s*\(/g,
+      /\bfor\s*\(/g,
+      /\bcase\s+/g,
+      /&&/g,
+      /\|\|/g,
+      /\?(?!=)/g,
+      // Ternary ? but not ?. or ??
+      /\bcatch\s*\(/g
+    ];
+    DEFAULT_THRESHOLDS2 = {
+      fanOut: { warn: 15 },
+      fanIn: { info: 20 },
+      couplingRatio: { warn: 0.7 },
+      transitiveDependencyDepth: { info: 30 }
+    };
+    pythonStrategy = {
+      extractImports(root) {
+        const imports = [];
+        for (const child of root.children) {
+          if (child.type === "import_statement") {
+            const imp = extractPythonImport(child);
+            if (imp) imports.push(imp);
+          } else if (child.type === "import_from_statement") {
+            imports.push(extractPythonFromImport(child));
+          }
+        }
+        return imports;
+      },
+      extractExports(root) {
+        const exports = [];
+        for (const child of root.children) {
+          const exp = extractPythonExport(child);
+          if (exp) exports.push(exp);
+        }
+        return exports;
+      }
+    };
+    goStrategy = {
+      extractImports(root) {
+        const imports = [];
+        for (const child of root.children) {
+          if (child.type === "import_declaration") imports.push(...extractGoImportsFromDecl(child));
+        }
+        return imports;
+      },
+      extractExports(root) {
+        const exports = [];
+        for (const child of root.children) {
+          const exp = extractGoExport(child);
+          if (exp) exports.push(exp);
+        }
+        return exports;
+      }
+    };
+    RUST_USE_ARG_TYPES = /* @__PURE__ */ new Set([
+      "scoped_identifier",
+      "use_wildcard",
+      "scoped_use_list",
+      "identifier"
+    ]);
+    RUST_PUB_ITEM_TYPES = /* @__PURE__ */ new Set([
+      "function_item",
+      "struct_item",
+      "enum_item",
+      "trait_item",
+      "type_item",
+      "const_item",
+      "static_item"
+    ]);
+    rustStrategy = {
+      extractImports(root) {
+        const imports = [];
+        for (const child of root.children) {
+          if (child.type !== "use_declaration") continue;
+          const arg = child.childForFieldName("argument") ?? child.children.find((c) => RUST_USE_ARG_TYPES.has(c.type));
+          if (arg) imports.push(makeImport(child, arg.text));
+        }
+        return imports;
+      },
+      extractExports(root, source) {
+        const exports = [];
+        const lines = source.split("\n");
+        for (const child of root.children) {
+          const line = lines[child.startPosition.row] ?? "";
+          if (!/^\s*pub\b/.test(line)) continue;
+          if (RUST_PUB_ITEM_TYPES.has(child.type)) {
+            const exp = makeNamedExport(child);
+            if (exp) exports.push(exp);
+          } else if (child.type === "mod_item") {
+            const name = child.childForFieldName("name");
+            if (name) {
+              exports.push({
+                name: name.text,
+                type: "namespace",
+                location: makeLocation2(child),
+                isReExport: false
+              });
+            }
+          }
+        }
+        return exports;
+      }
+    };
+    JAVA_IMPORT_TYPES = /* @__PURE__ */ new Set(["scoped_identifier", "scoped_absolute_identifier"]);
+    JAVA_EXPORT_TYPES = /* @__PURE__ */ new Set([
+      "class_declaration",
+      "interface_declaration",
+      "enum_declaration",
+      "record_declaration"
+    ]);
+    javaStrategy = {
+      extractImports(root) {
+        const imports = [];
+        for (const child of root.children) {
+          if (child.type !== "import_declaration") continue;
+          const scoped = child.children.find((c) => JAVA_IMPORT_TYPES.has(c.type));
+          if (scoped) imports.push(makeImport(child, scoped.text));
+        }
+        return imports;
+      },
+      extractExports(root, source) {
+        const exports = [];
+        const lines = source.split("\n");
+        for (const child of root.children) {
+          if (!JAVA_EXPORT_TYPES.has(child.type)) continue;
+          const line = lines[child.startPosition.row] ?? "";
+          if (!/\bpublic\b/.test(line)) continue;
+          const exp = makeNamedExport(child);
+          if (exp) exports.push(exp);
+        }
+        return exports;
+      }
+    };
+    STRATEGIES = {
+      python: pythonStrategy,
+      go: goStrategy,
+      rust: rustStrategy,
+      java: javaStrategy
+    };
+    TreeSitterParser = class {
+      name;
+      extensions;
+      lang;
+      strategy;
+      constructor(lang, extensions, strategy) {
+        this.name = lang;
+        this.lang = lang;
+        this.extensions = extensions;
+        this.strategy = strategy;
+      }
+      async parseFile(path) {
+        const contentResult = await readFileContent(path);
+        if (!contentResult.ok) {
+          return Err(
+            createParseError("NOT_FOUND", `File not found: ${path}`, { path }, [
+              "Check that the file exists"
+            ])
+          );
+        }
+        try {
+          const parser = await getParser(this.lang);
+          const tree = parser.parse(contentResult.value);
+          return Ok({
+            type: "Program",
+            body: { tree, source: contentResult.value },
+            language: this.lang
+          });
+        } catch (e) {
+          const error = e;
+          return Err(
+            createParseError("SYNTAX_ERROR", `Failed to parse ${path}: ${error.message}`, { path }, [
+              "Check for syntax errors in the file"
+            ])
+          );
+        }
+      }
+      extractImports(ast) {
+        const { tree, source } = ast.body;
+        return Ok(this.strategy.extractImports(tree.rootNode, source));
+      }
+      extractExports(ast) {
+        const { tree, source } = ast.body;
+        return Ok(this.strategy.extractExports(tree.rootNode, source));
+      }
+      async health() {
+        try {
+          await getParser(this.lang);
+          return Ok({ available: true, message: `tree-sitter ${this.lang} grammar loaded` });
+        } catch {
+          return Ok({ available: false, message: `tree-sitter ${this.lang} grammar not available` });
+        }
+      }
+      outline(filePath, ast) {
+        const { tree, source } = ast.body;
+        return extractOutlineFromTree(tree.rootNode, this.lang, source, filePath);
+      }
+      unfold(filePath, ast, symbolName) {
+        const outlineResult = this.outline(filePath, ast);
+        if (outlineResult.error || !outlineResult.symbols.length) return null;
+        const { source } = ast.body;
+        const match = findSymbolByName(outlineResult.symbols, symbolName);
+        if (!match) return null;
+        const lines = source.split("\n");
+        const content = lines.slice(match.line - 1, match.endLine).join("\n");
+        return {
+          file: filePath,
+          symbolName,
+          startLine: match.line,
+          endLine: match.endLine,
+          content,
+          language: this.lang,
+          fallback: false
+        };
+      }
+    };
+    ParserRegistry = class {
+      parsers = /* @__PURE__ */ new Map();
+      register(parser) {
+        this.parsers.set(parser.name, parser);
+      }
+      getByLanguage(lang) {
+        return this.parsers.get(lang) ?? null;
+      }
+      getForFile(filePath) {
+        const lang = detectLanguage(filePath);
+        if (!lang) return null;
+        return this.getByLanguage(lang);
+      }
+      getSupportedExtensions() {
+        return Object.keys(EXTENSION_MAP);
+      }
+      getSupportedLanguages() {
+        return Array.from(this.parsers.keys());
+      }
+      isSupportedExtension(ext) {
+        return ext in EXTENSION_MAP;
+      }
+    };
+    defaultRegistry = null;
+  }
+});
+
+// ../core/dist/chunk-BTUDWWB4.mjs
+import { resolve as resolve2 } from "path";
+import { minimatch as minimatch2 } from "minimatch";
+import { join, resolve as resolve3 } from "path";
+import { dirname as dirname2, resolve as resolve32 } from "path";
+import { dirname as dirname22, extname as extname2, resolve as resolve4 } from "path";
+import { minimatch as minimatch22 } from "minimatch";
+import { readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+function collectFieldEntries(rootDir, field) {
+  if (typeof field === "string") return [resolve3(rootDir, field)];
+  if (typeof field === "object" && field !== null) {
+    return Object.values(field).filter((v) => typeof v === "string").map((v) => resolve3(rootDir, v));
+  }
+  return [];
+}
+function extractPackageEntries(rootDir, pkg) {
+  const entries = [];
+  entries.push(...collectFieldEntries(rootDir, pkg["exports"]));
+  if (entries.length === 0 && typeof pkg["main"] === "string") {
+    entries.push(resolve3(rootDir, pkg["main"]));
+  }
+  if (pkg["bin"]) entries.push(...collectFieldEntries(rootDir, pkg["bin"]));
+  return entries;
+}
+async function readPackageJsonEntries(rootDir, pkgPath) {
+  const content = await readFileContent(pkgPath);
+  if (!content.ok) return [];
+  try {
+    const pkg = JSON.parse(content.value);
+    return extractPackageEntries(rootDir, pkg);
+  } catch {
+    return [];
+  }
+}
+async function resolveTypeScript(rootDir) {
+  const pkgPath = join(rootDir, "package.json");
+  const detected = await fileExists(pkgPath);
+  if (detected) {
+    const entries = await readPackageJsonEntries(rootDir, pkgPath);
+    if (entries.length > 0) {
+      return { language: "typescript", detected: true, entries, hints: TS_HINTS };
+    }
+  }
+  for (const conv of TS_CONVENTIONS) {
+    const p = join(rootDir, conv);
+    if (await fileExists(p)) {
+      return { language: "typescript", detected: true, entries: [p], hints: TS_HINTS };
+    }
+  }
+  return { language: "typescript", detected, entries: [], hints: TS_HINTS };
+}
+async function detectPython(rootDir) {
+  return await fileExists(join(rootDir, "pyproject.toml")) || await fileExists(join(rootDir, "setup.py")) || await fileExists(join(rootDir, "requirements.txt"));
+}
+async function readPyProject(rootDir) {
+  const pyproject = join(rootDir, "pyproject.toml");
+  if (!await fileExists(pyproject)) return { scriptTargets: [] };
+  const content = await readFileContent(pyproject);
+  if (!content.ok) return { scriptTargets: [] };
+  return parsePyProject(content.value);
+}
+async function resolveScriptTargetEntry(rootDir, target) {
+  const mod = target.split(":")[0];
+  if (!mod) return void 0;
+  const relPath = mod.replaceAll(".", "/") + ".py";
+  for (const candidate of [join(rootDir, relPath), join(rootDir, "src", relPath)]) {
+    if (await fileExists(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function resolvePythonFromScripts(rootDir, targets) {
+  const entries = [];
+  for (const target of targets) {
+    const entry = await resolveScriptTargetEntry(rootDir, target);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+async function resolvePythonFromProjectName(rootDir, projectName) {
+  if (!projectName) return [];
+  const normalized = projectName.replaceAll("-", "_");
+  const candidates = [
+    join(rootDir, normalized, "__init__.py"),
+    join(rootDir, normalized, "__main__.py"),
+    join(rootDir, "src", normalized, "__init__.py"),
+    join(rootDir, "src", normalized, "__main__.py")
+  ];
+  const entries = [];
+  for (const c of candidates) {
+    if (await fileExists(c)) entries.push(c);
+  }
+  return entries;
+}
+async function resolvePythonConventions(rootDir) {
+  const entries = [];
+  for (const conv of PYTHON_CONVENTIONS) {
+    const p = join(rootDir, conv);
+    if (await fileExists(p)) entries.push(p);
+  }
+  return entries;
+}
+async function findPythonTopLevelPackages(rootDir) {
+  const found = await findFiles("*/__init__.py", rootDir);
+  if (found.length > 0) return found;
+  return findFiles("src/*/__init__.py", rootDir);
+}
+async function resolvePython(rootDir) {
+  if (!await detectPython(rootDir)) {
+    return { language: "python", detected: false, entries: [], hints: PYTHON_HINTS };
+  }
+  const info = await readPyProject(rootDir);
+  const strategies = [
+    () => resolvePythonFromScripts(rootDir, info.scriptTargets),
+    () => resolvePythonFromProjectName(rootDir, info.projectName),
+    () => resolvePythonConventions(rootDir),
+    () => findPythonTopLevelPackages(rootDir)
+  ];
+  for (const strategy of strategies) {
+    const entries = await strategy();
+    if (entries.length > 0) {
+      return { language: "python", detected: true, entries, hints: PYTHON_HINTS };
+    }
+  }
+  return { language: "python", detected: true, entries: [], hints: PYTHON_HINTS };
+}
+async function resolveGo(rootDir) {
+  const hints = ["Create main.go at the project root, or use the cmd/<name>/main.go layout"];
+  const detected = await fileExists(join(rootDir, "go.mod"));
+  if (!detected) return { language: "go", detected: false, entries: [], hints };
+  const entries = [];
+  const mainGo = join(rootDir, "main.go");
+  if (await fileExists(mainGo)) entries.push(mainGo);
+  entries.push(...await findFiles("cmd/*/main.go", rootDir));
+  return { language: "go", detected: true, entries, hints };
+}
+async function resolveRust(rootDir) {
+  const hints = [
+    "Create src/main.rs or src/lib.rs",
+    "Declare [[bin]] entries with a `path` in Cargo.toml"
+  ];
+  const cargoPath = join(rootDir, "Cargo.toml");
+  const detected = await fileExists(cargoPath);
+  if (!detected) return { language: "rust", detected: false, entries: [], hints };
+  const entries = [];
+  const content = await readFileContent(cargoPath);
+  if (content.ok) {
+    for (const bp of parseCargoBinPaths(content.value)) {
+      const abs = resolve3(rootDir, bp);
+      if (await fileExists(abs)) entries.push(abs);
+    }
+  }
+  if (entries.length === 0) {
+    for (const conv of ["src/main.rs", "src/lib.rs"]) {
+      const p = join(rootDir, conv);
+      if (await fileExists(p)) entries.push(p);
+    }
+    entries.push(...await findFiles("src/bin/*.rs", rootDir));
+  }
+  return { language: "rust", detected: true, entries, hints };
+}
+async function resolveJava(rootDir) {
+  const hints = [
+    "Place an entry class at src/main/java/**/Main.java (or *Application.java for Spring Boot)"
+  ];
+  const detected = await fileExists(join(rootDir, "pom.xml")) || await fileExists(join(rootDir, "build.gradle")) || await fileExists(join(rootDir, "build.gradle.kts"));
+  if (!detected) return { language: "java", detected: false, entries: [], hints };
+  const entries = [];
+  entries.push(...await findFiles("src/main/java/**/Main.java", rootDir));
+  entries.push(...await findFiles("src/main/java/**/*Application.java", rootDir));
+  return { language: "java", detected: true, entries, hints };
+}
+function parseTomlLine(raw) {
+  const line = raw.replace(/(^|\s)#.*$/, "").trim();
+  if (!line) return {};
+  const sectionMatch = /^\[([^\]]+)\]$/.exec(line);
+  if (sectionMatch) return { section: sectionMatch[1] ?? "" };
+  const eq = line.indexOf("=");
+  if (eq <= 0) return {};
+  return {
+    key: line.slice(0, eq).trim(),
+    value: stripTomlString(line.slice(eq + 1).trim())
+  };
+}
+function parsePyProject(content) {
+  const result = { scriptTargets: [] };
+  let section = null;
+  for (const raw of content.split(/\r?\n/)) {
+    const parsed = parseTomlLine(raw);
+    if (parsed.section !== void 0) {
+      section = parsed.section;
+      continue;
+    }
+    if (parsed.key === void 0 || parsed.value === void 0) continue;
+    if (section === "project" && parsed.key === "name") result.projectName = parsed.value;
+    else if (section === "project.scripts") result.scriptTargets.push(parsed.value);
+  }
+  return result;
+}
+function parseCargoBinPaths(content) {
+  const paths = [];
+  let inBin = false;
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.replace(/(^|\s)#.*$/, "").trim();
+    if (!line) continue;
+    if (line === "[[bin]]") {
+      inBin = true;
+      continue;
+    }
+    if (line.startsWith("[")) {
+      inBin = false;
+      continue;
+    }
+    if (!inBin) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (key === "path") paths.push(stripTomlString(line.slice(eq + 1).trim()));
+  }
+  return paths;
+}
+function stripTomlString(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+async function resolveEntryPoints(rootDir, explicitEntries) {
+  if (explicitEntries && explicitEntries.length > 0) {
+    return Ok(explicitEntries.map((e) => resolve3(rootDir, e)));
+  }
+  const resolvers = [resolveTypeScript, resolvePython, resolveGo, resolveRust, resolveJava];
+  const resolutions = [];
+  for (const resolver of resolvers) {
+    const res = await resolver(rootDir);
+    resolutions.push(res);
+    if (res.entries.length > 0) return Ok(res.entries);
+  }
+  const detectedLangs = resolutions.filter((r) => r.detected);
+  const suggestions = detectedLangs.length > 0 ? detectedLangs.flatMap((r) => r.hints) : resolutions.flatMap((r) => r.hints);
+  suggestions.push("Specify entryPoints in config");
+  const reason = detectedLangs.length > 0 ? `Detected ${detectedLangs.map((r) => r.language).join(", ")} project but found no entry points` : "No language manifest (package.json, pyproject.toml, go.mod, Cargo.toml, pom.xml) and no conventional entry files found";
+  return Err(
+    createEntropyError(
+      "ENTRY_POINT_NOT_FOUND",
+      "Could not resolve entry points",
+      { reason },
+      suggestions
+    )
+  );
+}
+function extractCodeBlocks(content) {
+  const blocks = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && line.startsWith("```")) {
+      const langMatch = line.match(/```(\w*)/);
+      const language = langMatch?.[1] || "text";
+      let codeContent = "";
+      let j = i + 1;
+      let currentLine = lines[j];
+      while (j < lines.length && currentLine !== void 0 && !currentLine.startsWith("```")) {
+        codeContent += currentLine + "\n";
+        j++;
+        currentLine = lines[j];
+      }
+      blocks.push({
+        language,
+        content: codeContent.trim(),
+        line: i + 1
+      });
+      i = j;
+    }
+  }
+  return blocks;
+}
+function extractInlineRefs(content) {
+  const refs = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const regex = /`([^`]+)`/g;
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      const reference = match[1];
+      if (reference === void 0) continue;
+      if (reference.match(/^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*(\(.*\))?$/)) {
+        refs.push({
+          reference: reference.replace(/\(.*\)$/, ""),
+          // Remove function parens
+          line: i + 1,
+          column: match.index
+        });
+      }
+    }
+  }
+  return refs;
+}
+async function parseDocumentationFile(path) {
+  const contentResult = await readFileContent(path);
+  if (!contentResult.ok) {
+    return Err(
+      createEntropyError(
+        "PARSE_ERROR",
+        `Failed to read documentation file: ${path}`,
+        { file: path },
+        ["Check that the file exists"]
+      )
+    );
+  }
+  const content = contentResult.value;
+  const type = path.endsWith(".md") ? "markdown" : "text";
+  return Ok({
+    path,
+    type,
+    content,
+    codeBlocks: extractCodeBlocks(content),
+    inlineRefs: extractInlineRefs(content)
+  });
+}
+function makeInternalSymbol(name, type, line) {
+  return { name, type, line, references: 0, calledBy: [] };
+}
+function extractFunctionSymbol(node, line) {
+  if (node.id?.name) return [makeInternalSymbol(node.id.name, "function", line)];
+  return [];
+}
+function extractVariableSymbols(node, line) {
+  return (node.declarations || []).filter((decl) => decl.id?.name).map((decl) => makeInternalSymbol(decl.id.name, "variable", line));
+}
+function extractClassSymbol(node, line) {
+  if (node.id?.name) return [makeInternalSymbol(node.id.name, "class", line)];
+  return [];
+}
+function extractSymbolsFromNode(node) {
+  const line = node.loc?.start?.line || 0;
+  if (node.type === "FunctionDeclaration") return extractFunctionSymbol(node, line);
+  if (node.type === "VariableDeclaration") return extractVariableSymbols(node, line);
+  if (node.type === "ClassDeclaration") return extractClassSymbol(node, line);
+  return [];
+}
+function extractInternalSymbols(ast) {
+  if (ast.language !== "typescript" && ast.language !== "javascript") return [];
+  const body = ast.body;
+  if (!body?.body) return [];
+  const nodes = body.body;
+  return nodes.flatMap(extractSymbolsFromNode);
+}
+function toJSDocComment(comment) {
+  if (comment.type !== "Block" || !comment.value?.startsWith("*")) return null;
+  return { content: comment.value, line: comment.loc?.start?.line || 0 };
+}
+function extractJSDocComments(ast) {
+  if (ast.language !== "typescript" && ast.language !== "javascript") return [];
+  const body = ast.body;
+  if (!body?.comments) return [];
+  return body.comments.flatMap((c) => {
+    const doc = toJSDocComment(c);
+    return doc ? [doc] : [];
+  });
+}
+function buildExportMap(files) {
+  const byFile = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    byFile.set(file.path, file.exports);
+    for (const exp of file.exports) {
+      const existing = byName.get(exp.name) || [];
+      existing.push({ file: file.path, export: exp });
+      byName.set(exp.name, existing);
+    }
+  }
+  return { byFile, byName };
+}
+function refsFromInlineRefs(doc) {
+  return doc.inlineRefs.map((inlineRef) => ({
+    docFile: doc.path,
+    line: inlineRef.line,
+    column: inlineRef.column,
+    reference: inlineRef.reference,
+    context: "inline"
+  }));
+}
+function refsFromCodeBlock(docPath, block) {
+  if (!CODE_BLOCK_LANGUAGES.has(block.language)) return [];
+  const refs = [];
+  const importRegex = /import\s+\{([^}]+)\}\s+from/g;
+  let match;
+  while ((match = importRegex.exec(block.content)) !== null) {
+    const group = match[1];
+    if (group === void 0) continue;
+    for (const name of group.split(",").map((n) => n.trim())) {
+      refs.push({
+        docFile: docPath,
+        line: block.line,
+        column: 0,
+        reference: name,
+        context: "code-block"
+      });
+    }
+  }
+  return refs;
+}
+function refsFromCodeBlocks(doc) {
+  return doc.codeBlocks.flatMap((block) => refsFromCodeBlock(doc.path, block));
+}
+function extractAllCodeReferences(docs) {
+  return docs.flatMap((doc) => [...refsFromInlineRefs(doc), ...refsFromCodeBlocks(doc)]);
+}
+async function buildSnapshot(config) {
+  const startTime = Date.now();
+  const rootDir = resolve2(config.rootDir);
+  const entryPointsResult = await resolveEntryPoints(rootDir, config.entryPoints);
+  if (!entryPointsResult.ok) {
+    return Err(entryPointsResult.error);
+  }
+  const registry = getDefaultRegistry();
+  const singleParser = config.parser;
+  const parserForFile = (filePath) => singleParser ?? registry.getForFile(filePath);
+  const includePatterns = config.include || DEFAULT_INCLUDE_PATTERNS;
+  const excludePatterns = config.exclude || [...skipDirGlobs(), "**/*.test.ts", "**/*.spec.ts"];
+  let sourceFilePaths = [];
+  for (const pattern of includePatterns) {
+    const files2 = await findFiles(pattern, rootDir);
+    sourceFilePaths.push(...files2);
+  }
+  sourceFilePaths = sourceFilePaths.filter((f) => {
+    const rel = relativePosix(rootDir, f);
+    return !excludePatterns.some((p) => minimatch2(rel, p));
+  });
+  const files = [];
+  for (const filePath of sourceFilePaths) {
+    const fileParser = parserForFile(filePath);
+    if (!fileParser) continue;
+    const parseResult = await fileParser.parseFile(filePath);
+    if (!parseResult.ok) continue;
+    const importsResult = fileParser.extractImports(parseResult.value);
+    const exportsResult = fileParser.extractExports(parseResult.value);
+    const internalSymbols = extractInternalSymbols(parseResult.value);
+    const jsDocComments = extractJSDocComments(parseResult.value);
+    files.push({
+      path: filePath,
+      ast: parseResult.value,
+      imports: importsResult.ok ? importsResult.value : [],
+      exports: exportsResult.ok ? exportsResult.value : [],
+      internalSymbols,
+      jsDocComments
+    });
+  }
+  const graphResult = await buildDependencyGraph(sourceFilePaths, singleParser ?? registry);
+  const dependencyGraph = graphResult.ok ? graphResult.value : { nodes: [], edges: [] };
+  const docPatterns = config.docPaths || ["docs/**/*.md", "README.md", "**/README.md"];
+  let docFilePaths = [];
+  for (const pattern of docPatterns) {
+    const docFiles = await findFiles(pattern, rootDir);
+    docFilePaths.push(...docFiles);
+  }
+  docFilePaths = [...new Set(docFilePaths)];
+  const docs = [];
+  for (const docPath of docFilePaths) {
+    const docResult = await parseDocumentationFile(docPath);
+    if (docResult.ok) {
+      docs.push(docResult.value);
+    }
+  }
+  const exportMap = buildExportMap(files);
+  const codeReferences = extractAllCodeReferences(docs);
+  const buildTime = Date.now() - startTime;
+  return Ok({
+    files,
+    dependencyGraph,
+    exportMap,
+    docs,
+    codeReferences,
+    entryPoints: entryPointsResult.value,
+    rootDir,
+    config,
+    buildTime
+  });
+}
+function initLevenshteinMatrix(aLen, bLen) {
+  const matrix = [];
+  for (let i = 0; i <= bLen; i++) {
+    matrix[i] = [i];
+  }
+  const firstRow = matrix[0];
+  if (firstRow) {
+    for (let j = 0; j <= aLen; j++) {
+      firstRow[j] = j;
+    }
+  }
+  return matrix;
+}
+function computeLevenshteinCell(row, prevRow, j, charsMatch) {
+  if (charsMatch) {
+    row[j] = prevRow[j - 1] ?? 0;
+  } else {
+    row[j] = Math.min((prevRow[j - 1] ?? 0) + 1, (row[j - 1] ?? 0) + 1, (prevRow[j] ?? 0) + 1);
+  }
+}
+function levenshteinDistance(a, b) {
+  const matrix = initLevenshteinMatrix(a.length, b.length);
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      const row = matrix[i];
+      const prevRow = matrix[i - 1];
+      if (!row || !prevRow) continue;
+      computeLevenshteinCell(row, prevRow, j, b.charAt(i - 1) === a.charAt(j - 1));
+    }
+  }
+  const lastRow = matrix[b.length];
+  return lastRow?.[a.length] ?? 0;
+}
+function findPossibleMatches(reference, exportNames, maxDistance = 5) {
+  const matches = [];
+  const refLower = reference.toLowerCase();
+  for (const name of exportNames) {
+    const nameLower = name.toLowerCase();
+    if (nameLower === refLower) {
+      matches.push({ name, score: 0 });
+      continue;
+    }
+    if (nameLower.includes(refLower) || refLower.includes(nameLower)) {
+      matches.push({ name, score: 1 });
+      continue;
+    }
+    const distance = levenshteinDistance(refLower, nameLower);
+    if (distance <= maxDistance) {
+      matches.push({ name, score: distance });
+    }
+  }
+  return matches.sort((a, b) => a.score - b.score).slice(0, 3).map((m) => m.name);
+}
+function checkApiSignatureDrift(snapshot, config) {
+  const drifts = [];
+  const exportNames = Array.from(snapshot.exportMap.byName.keys());
+  for (const ref of snapshot.codeReferences) {
+    if (config.ignorePatterns.some((p) => ref.reference.match(new RegExp(p)))) {
+      continue;
+    }
+    if (!snapshot.exportMap.byName.has(ref.reference)) {
+      const possibleMatches = findPossibleMatches(ref.reference, exportNames);
+      const confidence = possibleMatches.length > 0 ? "high" : "medium";
+      const drift = {
+        type: "api-signature",
+        docFile: ref.docFile,
+        line: ref.line,
+        reference: ref.reference,
+        context: ref.context,
+        issue: possibleMatches.length > 0 ? "RENAMED" : "NOT_FOUND",
+        details: possibleMatches.length > 0 ? `Symbol "${ref.reference}" not found. Similar: ${possibleMatches.join(", ")}` : `Symbol "${ref.reference}" not found in codebase`,
+        suggestion: possibleMatches.length > 0 ? `Did you mean "${possibleMatches[0]}"?` : "Remove reference or add the missing export",
+        confidence
+      };
+      if (possibleMatches.length > 0) {
+        drift.possibleMatches = possibleMatches;
+      }
+      drifts.push(drift);
+    }
+  }
+  return drifts;
+}
+function extractFileLinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const linkRegex = /\[([^\]]*)\]\(([^)]+)\)/g;
+    let match;
+    while ((match = linkRegex.exec(line)) !== null) {
+      const linkPath = match[2];
+      if (linkPath && !linkPath.startsWith("http") && !linkPath.startsWith("#") && (linkPath.includes(".") || linkPath.startsWith(".."))) {
+        links.push({ link: linkPath, line: i + 1 });
+      }
+    }
+  }
+  return links;
+}
+async function checkStructureDrift(snapshot, _config) {
+  const drifts = [];
+  for (const doc of snapshot.docs) {
+    const fileLinks = extractFileLinks(doc.content);
+    for (const { link, line } of fileLinks) {
+      const resolvedPath = resolve32(dirname2(doc.path), link);
+      const exists = await fileExists(resolvedPath);
+      if (!exists) {
+        drifts.push({
+          type: "structure",
+          docFile: doc.path,
+          line,
+          reference: link,
+          context: "link",
+          issue: "NOT_FOUND",
+          details: `File "${link}" referenced in documentation does not exist`,
+          suggestion: "Update the link or remove the reference",
+          confidence: "high"
+        });
+      }
+    }
+  }
+  return drifts;
+}
+function computeDriftSeverity(driftCount) {
+  if (driftCount === 0) return "none";
+  if (driftCount <= 3) return "low";
+  if (driftCount <= 10) return "medium";
+  return "high";
+}
+function buildGraphDriftReport(graphDriftData) {
+  const drifts = [];
+  for (const target of graphDriftData.missingTargets) {
+    drifts.push({
+      type: "api-signature",
+      docFile: target,
+      line: 0,
+      reference: target,
+      context: "graph-missing-target",
+      issue: "NOT_FOUND",
+      details: `Graph node "${target}" has no matching code target`,
+      confidence: "high"
+    });
+  }
+  for (const edge of graphDriftData.staleEdges) {
+    drifts.push({
+      type: "api-signature",
+      docFile: edge.docNodeId,
+      line: 0,
+      reference: edge.codeNodeId,
+      context: `graph-stale-edge:${edge.edgeType}`,
+      issue: "NOT_FOUND",
+      details: `Stale edge from doc "${edge.docNodeId}" to code "${edge.codeNodeId}" (${edge.edgeType})`,
+      confidence: "medium"
+    });
+  }
+  return Ok({
+    drifts,
+    stats: {
+      docsScanned: graphDriftData.staleEdges.length,
+      referencesChecked: graphDriftData.staleEdges.length + graphDriftData.missingTargets.length,
+      driftsFound: drifts.length,
+      byType: { api: drifts.length, example: 0, structure: 0 }
+    },
+    severity: computeDriftSeverity(drifts.length)
+  });
+}
+async function detectDocDrift(snapshot, config, graphDriftData) {
+  if (graphDriftData) {
+    return buildGraphDriftReport(graphDriftData);
+  }
+  const fullConfig = { ...DEFAULT_DRIFT_CONFIG, ...config };
+  const drifts = [];
+  if (fullConfig.checkApiSignatures) {
+    drifts.push(...checkApiSignatureDrift(snapshot, fullConfig));
+  }
+  if (fullConfig.checkStructure) {
+    drifts.push(...await checkStructureDrift(snapshot, fullConfig));
+  }
+  const apiDrifts = drifts.filter((d) => d.type === "api-signature").length;
+  const exampleDrifts = drifts.filter((d) => d.type === "example-code").length;
+  const structureDrifts = drifts.filter((d) => d.type === "structure").length;
+  const severity = drifts.length === 0 ? "none" : drifts.length <= 3 ? "low" : drifts.length <= 10 ? "medium" : "high";
+  return Ok({
+    drifts,
+    stats: {
+      docsScanned: snapshot.docs.length,
+      referencesChecked: snapshot.codeReferences.length,
+      driftsFound: drifts.length,
+      byType: { api: apiDrifts, example: exampleDrifts, structure: structureDrifts }
+    },
+    severity
+  });
+}
+function buildFileIndex(snapshot) {
+  const index = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    index.set(file.path, file);
+  }
+  return index;
+}
+function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
+  if (!importSource.startsWith(".")) {
+    return null;
+  }
+  const hasFile = fileIndex ? (p) => fileIndex.has(p) : (p) => snapshot.files.some((f) => f.path === p);
+  const fromDir = dirname22(fromFile);
+  const resolved = resolve4(fromDir, importSource);
+  const sourceExt = extname2(resolved);
+  const fallbacks = JS_EXT_FALLBACKS2[sourceExt];
+  if (fallbacks) {
+    const base = resolved.slice(0, -sourceExt.length);
+    for (const ext of fallbacks) {
+      const candidate = base + ext;
+      if (hasFile(candidate)) return candidate;
+    }
+    for (const indexExt of [".ts", ".tsx", ".jsx"]) {
+      const indexPath = resolve4(base, "index" + indexExt);
+      if (hasFile(indexPath)) return indexPath;
+    }
+  }
+  if (hasFile(resolved)) return resolved;
+  if (!sourceExt) {
+    for (const ext of [".ts", ".tsx"]) {
+      const candidate = resolved + ext;
+      if (hasFile(candidate)) return candidate;
+    }
+    for (const indexExt of [".ts", ".tsx"]) {
+      const indexPath = resolve4(resolved, "index" + indexExt);
+      if (hasFile(indexPath)) return indexPath;
+    }
+  }
+  return null;
+}
+function enqueueResolved(sources, current, snapshot, visited, queue, fileIndex) {
+  for (const item of sources) {
+    if (!item.source) continue;
+    const resolved = resolveImportToFile(item.source, current, snapshot, fileIndex);
+    if (resolved && !visited.has(resolved)) {
+      queue.push(resolved);
+    }
+  }
+}
+function processReachabilityNode(current, snapshot, reachability, visited, queue, fileIndex) {
+  reachability.set(current, true);
+  const sourceFile = fileIndex ? fileIndex.get(current) : snapshot.files.find((f) => f.path === current);
+  if (!sourceFile) return;
+  enqueueResolved(sourceFile.imports, current, snapshot, visited, queue, fileIndex);
+  const reExports = sourceFile.exports.filter((e) => e.isReExport);
+  enqueueResolved(reExports, current, snapshot, visited, queue, fileIndex);
+}
+function buildReachabilityMap(snapshot) {
+  const fileIndex = buildFileIndex(snapshot);
+  const reachability = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    reachability.set(file.path, false);
+  }
+  const queue = [...snapshot.entryPoints];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) continue;
+    visited.add(current);
+    processReachabilityNode(current, snapshot, reachability, visited, queue, fileIndex);
+  }
+  return reachability;
+}
+function buildExportUsageMap(snapshot) {
+  const fileIndex = buildFileIndex(snapshot);
+  const usageMap = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    for (const exp of file.exports) {
+      const key = `${file.path}:${exp.name}`;
+      usageMap.set(key, { importers: [], isReExported: exp.isReExport });
+    }
+  }
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const resolvedFile = resolveImportToFile(imp.source, file.path, snapshot, fileIndex);
+      if (!resolvedFile) continue;
+      const sourceFile = fileIndex.get(resolvedFile);
+      if (!sourceFile) continue;
+      for (const specifier of imp.specifiers) {
+        const matchingExport = sourceFile.exports.find(
+          (e) => e.name === specifier || specifier === "default" && e.type === "default"
+        );
+        if (matchingExport) {
+          const key = `${resolvedFile}:${matchingExport.name}`;
+          const usage = usageMap.get(key);
+          if (usage) {
+            usage.importers.push(file.path);
+          }
+        }
+      }
+    }
+  }
+  return usageMap;
+}
+function findDeadExports(snapshot, usageMap, reachability) {
+  const deadExports = [];
+  for (const file of snapshot.files) {
+    if (snapshot.entryPoints.includes(file.path)) continue;
+    for (const exp of file.exports) {
+      if (exp.isReExport) continue;
+      const key = `${file.path}:${exp.name}`;
+      const usage = usageMap.get(key);
+      if (!usage || usage.importers.length === 0) {
+        deadExports.push({
+          file: file.path,
+          name: exp.name,
+          line: exp.location.line,
+          type: "variable",
+          // Default type since Export doesn't track declaration kind
+          isDefault: exp.type === "default",
+          reason: "NO_IMPORTERS"
+        });
+      } else {
+        const allImportersDead = usage.importers.every((importer) => !reachability.get(importer));
+        if (allImportersDead) {
+          deadExports.push({
+            file: file.path,
+            name: exp.name,
+            line: exp.location.line,
+            type: "variable",
+            // Default type since Export doesn't track declaration kind
+            isDefault: exp.type === "default",
+            reason: "IMPORTERS_ALSO_DEAD"
+          });
+        }
+      }
+    }
+  }
+  return deadExports;
+}
+function maxLineOfValue(value) {
+  if (Array.isArray(value)) {
+    return value.reduce((m, item) => Math.max(m, findMaxLineInNode(item)), 0);
+  }
+  if (value && typeof value === "object") {
+    return findMaxLineInNode(value);
+  }
+  return 0;
+}
+function maxLineOfNodeKeys(node) {
+  let max = 0;
+  for (const key of Object.keys(node)) {
+    max = Math.max(max, maxLineOfValue(node[key]));
+  }
+  return max;
+}
+function findMaxLineInNode(node) {
+  if (!node || typeof node !== "object") return 0;
+  const n = node;
+  const locLine = n.loc?.end?.line ?? 0;
+  return Math.max(locLine, maxLineOfNodeKeys(node));
+}
+function countLinesFromAST(ast) {
+  if (!ast.body || !Array.isArray(ast.body)) return 1;
+  const maxLine = findMaxLineInNode(ast);
+  if (maxLine > 0) return maxLine;
+  return Math.max(ast.body.length * 3, 1);
+}
+function findDeadFiles(snapshot, reachability) {
+  const deadFiles = [];
+  for (const file of snapshot.files) {
+    const isReachable = reachability.get(file.path) ?? false;
+    if (!isReachable) {
+      deadFiles.push({
+        path: file.path,
+        reason: "NO_IMPORTERS",
+        exportCount: file.exports.filter((e) => !e.isReExport).length,
+        lineCount: countLinesFromAST(file.ast)
+      });
+    }
+  }
+  return deadFiles;
+}
+function isIdentifierUsedInAST(ast, identifier, skipImportDeclaration = true) {
+  const astString = JSON.stringify(
+    ast,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  );
+  const identifierPattern = new RegExp(`"name"\\s*:\\s*"${identifier}"`, "g");
+  const matches = astString.match(identifierPattern);
+  if (!matches) return false;
+  if (skipImportDeclaration) {
+    return matches.length > 2;
+  }
+  return matches.length > 0;
+}
+function findUnusedImports(snapshot) {
+  const unusedImports = [];
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const unusedSpecifiers = [];
+      for (const specifier of imp.specifiers) {
+        if (!isIdentifierUsedInAST(file.ast, specifier, true)) {
+          unusedSpecifiers.push(specifier);
+        }
+      }
+      if (unusedSpecifiers.length > 0) {
+        unusedImports.push({
+          file: file.path,
+          line: imp.location.line,
+          source: imp.source,
+          specifiers: unusedSpecifiers,
+          isFullyUnused: unusedSpecifiers.length === imp.specifiers.length
+        });
+      }
+    }
+  }
+  return unusedImports;
+}
+function findDeadInternals(snapshot, _reachability) {
+  const deadInternals = [];
+  for (const file of snapshot.files) {
+    for (const symbol of file.internalSymbols) {
+      if (symbol.type === "type") continue;
+      if (symbol.references === 0 && symbol.calledBy.length === 0) {
+        deadInternals.push({
+          file: file.path,
+          name: symbol.name,
+          line: symbol.line,
+          type: symbol.type,
+          reason: "NEVER_CALLED"
+        });
+      }
+    }
+  }
+  return deadInternals;
+}
+function classifyUnreachableNode(node, deadFiles, deadExports) {
+  if (FILE_TYPES.has(node.type)) {
+    deadFiles.push({
+      path: node.path || node.id,
+      reason: "NO_IMPORTERS",
+      exportCount: 0,
+      lineCount: 0
+    });
+  } else if (EXPORT_TYPES.has(node.type)) {
+    const exportType = node.type === "method" ? "function" : node.type;
+    deadExports.push({
+      file: node.path || node.id,
+      name: node.name,
+      line: 0,
+      type: exportType,
+      isDefault: false,
+      reason: "NO_IMPORTERS"
+    });
+  }
+}
+function computeGraphReportStats(data, deadFiles, deadExports) {
+  const reachableCount = data.reachableNodeIds instanceof Set ? data.reachableNodeIds.size : data.reachableNodeIds.length;
+  const fileNodes = data.unreachableNodes.filter((n) => FILE_TYPES.has(n.type));
+  const exportNodes = data.unreachableNodes.filter((n) => EXPORT_TYPES.has(n.type));
+  const totalFiles = reachableCount + fileNodes.length;
+  const totalExports = exportNodes.length + (reachableCount > 0 ? reachableCount : 0);
+  return {
+    filesAnalyzed: totalFiles,
+    entryPointsUsed: [],
+    totalExports,
+    deadExportCount: deadExports.length,
+    totalFiles,
+    deadFileCount: deadFiles.length,
+    estimatedDeadLines: 0
+  };
+}
+function buildReportFromGraph(data) {
+  const deadFiles = [];
+  const deadExports = [];
+  for (const node of data.unreachableNodes) {
+    classifyUnreachableNode(node, deadFiles, deadExports);
+  }
+  return {
+    deadExports,
+    deadFiles,
+    deadInternals: [],
+    unusedImports: [],
+    stats: computeGraphReportStats(data, deadFiles, deadExports)
+  };
+}
+function buildReportFromSnapshot(snapshot) {
+  const reachability = buildReachabilityMap(snapshot);
+  const usageMap = buildExportUsageMap(snapshot);
+  const deadExports = findDeadExports(snapshot, usageMap, reachability);
+  const deadFiles = findDeadFiles(snapshot, reachability);
+  const unusedImports = findUnusedImports(snapshot);
+  const deadInternals = findDeadInternals(snapshot, reachability);
+  const totalExports = snapshot.files.reduce(
+    (acc, file) => acc + file.exports.filter((e) => !e.isReExport).length,
+    0
+  );
+  const estimatedDeadLines = deadFiles.reduce((acc, file) => acc + file.lineCount, 0);
+  return {
+    deadExports,
+    deadFiles,
+    deadInternals,
+    unusedImports,
+    stats: {
+      filesAnalyzed: snapshot.files.length,
+      entryPointsUsed: snapshot.entryPoints,
+      totalExports,
+      deadExportCount: deadExports.length,
+      totalFiles: snapshot.files.length,
+      deadFileCount: deadFiles.length,
+      estimatedDeadLines
+    }
+  };
+}
+function filterProtectedFindings(report, regions) {
+  const deadExports = report.deadExports.filter(
+    (e) => !regions.isProtected(e.file, e.line, "entropy")
+  );
+  const deadFiles = report.deadFiles.filter((f) => regions.getRegions(f.path).length === 0);
+  const unusedImports = report.unusedImports.filter(
+    (i) => !regions.isProtected(i.file, i.line, "entropy")
+  );
+  const deadInternals = report.deadInternals.filter(
+    (i) => !regions.isProtected(i.file, i.line, "entropy")
+  );
+  const estimatedDeadLines = deadFiles.reduce((acc, f) => acc + f.lineCount, 0);
+  return {
+    deadExports,
+    deadFiles,
+    unusedImports,
+    deadInternals,
+    stats: {
+      ...report.stats,
+      deadExportCount: deadExports.length,
+      deadFileCount: deadFiles.length,
+      estimatedDeadLines
+    }
+  };
+}
+async function detectDeadCode(snapshot, graphDeadCodeData, protectedRegions) {
+  let report = graphDeadCodeData ? buildReportFromGraph(graphDeadCodeData) : buildReportFromSnapshot(snapshot);
+  if (protectedRegions) {
+    report = filterProtectedFindings(report, protectedRegions);
+  }
+  return Ok(report);
+}
+function fileMatchesPattern(filePath, pattern, rootDir) {
+  const relativePath = relativePosix(rootDir, filePath);
+  return minimatch22(relativePath, pattern);
+}
+function checkMustExport(rule, file, message) {
+  if (rule.type !== "must-export") return [];
+  const matches = [];
+  for (const name of rule.names) {
+    if (!file.exports.some((e) => e.name === name)) {
+      matches.push({
+        line: 1,
+        message: message || `Missing required export: "${name}"`,
+        suggestion: `Add export for "${name}"`
+      });
+    }
+  }
+  return matches;
+}
+function checkMustExportDefault(_rule, file, message) {
+  if (!file.exports.some((e) => e.type === "default")) {
+    return [
+      {
+        line: 1,
+        message: message || "File must have a default export",
+        suggestion: "Add a default export"
+      }
+    ];
+  }
+  return [];
+}
+function checkNoExport(rule, file, message) {
+  if (rule.type !== "no-export") return [];
+  const matches = [];
+  for (const name of rule.names) {
+    const exp = file.exports.find((e) => e.name === name);
+    if (exp) {
+      matches.push({
+        line: exp.location.line,
+        message: message || `Forbidden export: "${name}"`,
+        suggestion: `Remove export "${name}"`
+      });
+    }
+  }
+  return matches;
+}
+function checkMustImport(rule, file, message) {
+  if (rule.type !== "must-import") return [];
+  const hasImport = file.imports.some(
+    (i) => i.source === rule.from || i.source.endsWith(rule.from)
+  );
+  if (!hasImport) {
+    return [
+      {
+        line: 1,
+        message: message || `Missing required import from "${rule.from}"`,
+        suggestion: `Add import from "${rule.from}"`
+      }
+    ];
+  }
+  return [];
+}
+function checkNoImport(rule, file, message) {
+  if (rule.type !== "no-import") return [];
+  const forbiddenImport = file.imports.find(
+    (i) => i.source === rule.from || i.source.endsWith(rule.from)
+  );
+  if (forbiddenImport) {
+    return [
+      {
+        line: forbiddenImport.location.line,
+        message: message || `Forbidden import from "${rule.from}"`,
+        suggestion: `Remove import from "${rule.from}"`
+      }
+    ];
+  }
+  return [];
+}
+function checkNaming(rule, file, message) {
+  if (rule.type !== "naming") return [];
+  const regex = new RegExp(rule.match);
+  const matches = [];
+  for (const exp of file.exports) {
+    if (!regex.test(exp.name)) {
+      const expected = CONVENTION_DESCRIPTIONS[rule.convention] ?? rule.convention;
+      matches.push({
+        line: exp.location.line,
+        message: message || `"${exp.name}" does not follow ${rule.convention} convention`,
+        suggestion: `Rename to follow ${expected}`
+      });
+    }
+  }
+  return matches;
+}
+function checkMaxExports(rule, file, message) {
+  if (rule.type !== "max-exports") return [];
+  if (file.exports.length > rule.count) {
+    return [
+      {
+        line: 1,
+        message: message || `File has ${file.exports.length} exports, max is ${rule.count}`,
+        suggestion: `Split into multiple files or reduce exports to ${rule.count}`
+      }
+    ];
+  }
+  return [];
+}
+function checkMaxLines(_rule, _file, _message) {
+  return [];
+}
+function checkRequireJsdoc(_rule, file, message) {
+  if (file.jsDocComments.length === 0 && file.exports.length > 0) {
+    return [
+      {
+        line: 1,
+        message: message || "Exported symbols require JSDoc documentation",
+        suggestion: "Add JSDoc comments to exports"
+      }
+    ];
+  }
+  return [];
+}
+function checkConfigPattern(pattern, file, rootDir) {
+  const fileMatches = pattern.files.some((glob2) => fileMatchesPattern(file.path, glob2, rootDir));
+  if (!fileMatches) return [];
+  const checker = RULE_CHECKERS[pattern.rule.type];
+  if (!checker) return [];
+  return checker(pattern.rule, file, pattern.message);
+}
+async function detectPatternViolations(snapshot, config) {
+  const violations = [];
+  const patterns = config?.patterns || [];
+  for (const file of snapshot.files) {
+    for (const pattern of patterns) {
+      const matches = checkConfigPattern(pattern, file, snapshot.rootDir);
+      for (const match of matches) {
+        violations.push({
+          pattern: pattern.name,
+          file: file.path,
+          line: match.line,
+          message: match.message,
+          suggestion: match.suggestion || "Review and fix this pattern violation",
+          severity: pattern.severity
+        });
+      }
+    }
+  }
+  if (config?.customPatterns) {
+    for (const file of snapshot.files) {
+      for (const custom of config.customPatterns) {
+        const matches = custom.check(file, snapshot);
+        for (const match of matches) {
+          violations.push({
+            pattern: custom.name,
+            file: file.path,
+            line: match.line,
+            message: match.message,
+            suggestion: match.suggestion || "Review and fix this pattern violation",
+            severity: custom.severity
+          });
+        }
+      }
+    }
+  }
+  const errorCount = violations.filter((v) => v.severity === "error").length;
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const customCount = config?.customPatterns?.length ?? 0;
+  const allPatternsCount = patterns.length + customCount;
+  const totalChecks = snapshot.files.length * allPatternsCount;
+  const passRate = totalChecks > 0 ? Math.max(0, (totalChecks - violations.length) / totalChecks) : 1;
+  return Ok({
+    violations,
+    stats: {
+      filesChecked: snapshot.files.length,
+      patternsApplied: allPatternsCount,
+      violationCount: violations.length,
+      errorCount,
+      warningCount
+    },
+    passRate
+  });
+}
+function parseSize(size) {
+  const match = size.trim().match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB|B)?$/i);
+  if (!match) return 0;
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || "B").toUpperCase();
+  switch (unit) {
+    case "KB":
+      return Math.round(value * 1024);
+    case "MB":
+      return Math.round(value * 1024 * 1024);
+    case "GB":
+      return Math.round(value * 1024 * 1024 * 1024);
+    default:
+      return Math.round(value);
+  }
+}
+function dirSize(dirPath) {
+  let total = 0;
+  let entries;
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    if (DEFAULT_SKIP_DIRS.has(entry)) continue;
+    const fullPath = join2(dirPath, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        total += dirSize(fullPath);
+      } else if (stat.isFile()) {
+        total += stat.size;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return total;
+}
+async function detectSizeBudgetViolations(rootDir, config) {
+  const budgets = config?.budgets ?? {};
+  const violations = [];
+  let packagesChecked = 0;
+  for (const [pkgPath, budget] of Object.entries(budgets)) {
+    packagesChecked++;
+    const distPath = join2(rootDir, pkgPath, "dist");
+    const currentSize = dirSize(distPath);
+    if (budget.warn) {
+      const budgetBytes = parseSize(budget.warn);
+      if (budgetBytes > 0 && currentSize > budgetBytes) {
+        violations.push({
+          package: pkgPath,
+          currentSize,
+          budgetSize: budgetBytes,
+          unit: "bytes",
+          tier: 2,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const infoCount = violations.filter((v) => v.severity === "info").length;
+  return Ok({
+    violations,
+    stats: {
+      packagesChecked,
+      violationCount: violations.length,
+      warningCount,
+      infoCount
+    }
+  });
+}
+function deadFileSuggestion(file) {
+  return {
+    type: "delete",
+    priority: "high",
+    source: "dead-code",
+    relatedIssues: [`dead-file:${file.path}`],
+    title: `Remove dead file: ${file.path.split("/").pop()}`,
+    description: `This file is not imported by any other file and can be safely removed.`,
+    files: [file.path],
+    steps: [`Delete ${file.path}`, "Run tests to verify no regressions"],
+    whyManual: "File deletion requires verification that no dynamic imports exist"
+  };
+}
+function deadExportSuggestion(exp) {
+  return {
+    type: "refactor",
+    priority: "medium",
+    source: "dead-code",
+    relatedIssues: [`dead-export:${exp.file}:${exp.name}`],
+    title: `Remove unused export: ${exp.name}`,
+    description: `The export "${exp.name}" is not used anywhere. Consider removing it.`,
+    files: [exp.file],
+    steps: [`Remove export "${exp.name}" from ${exp.file}`, "Run tests to verify no regressions"],
+    whyManual: "Export removal may affect external consumers not in scope"
+  };
+}
+function unusedImportSuggestion(imp) {
+  const plural = imp.specifiers.length > 1;
+  return {
+    type: "delete",
+    priority: "medium",
+    source: "dead-code",
+    relatedIssues: [`unused-import:${imp.file}:${imp.specifiers.join(",")}`],
+    title: `Remove unused import${plural ? "s" : ""}: ${imp.specifiers.join(", ")}`,
+    description: `The import${plural ? "s" : ""} from "${imp.source}" ${plural ? "are" : "is"} not used.`,
+    files: [imp.file],
+    steps: imp.isFullyUnused ? [`Remove entire import line from ${imp.file}`] : [`Remove unused specifiers (${imp.specifiers.join(", ")}) from import statement`],
+    whyManual: "Import removal can be auto-fixed"
+  };
+}
+function generateDeadCodeSuggestions(report) {
+  return [
+    ...report.deadFiles.map(deadFileSuggestion),
+    ...report.deadExports.map(deadExportSuggestion),
+    ...report.unusedImports.map(unusedImportSuggestion)
+  ];
+}
+function generateDriftSuggestions(report) {
+  const suggestions = [];
+  for (const drift of report.drifts) {
+    const priority = drift.confidence === "high" ? "high" : "medium";
+    suggestions.push({
+      type: "update-docs",
+      priority,
+      source: "drift",
+      relatedIssues: [`drift:${drift.docFile}:${drift.reference}`],
+      title: `Fix documentation drift: ${drift.reference}`,
+      description: drift.details,
+      files: [drift.docFile],
+      steps: [
+        drift.suggestion || "Review and update documentation",
+        "Review documentation for accuracy"
+      ],
+      whyManual: "Documentation updates require human judgment for accuracy"
+    });
+  }
+  return suggestions;
+}
+function generatePatternSuggestions(report) {
+  const suggestions = [];
+  for (const violation of report.violations) {
+    suggestions.push({
+      type: "refactor",
+      priority: violation.severity === "error" ? "high" : "low",
+      source: "pattern",
+      relatedIssues: [`pattern:${violation.pattern}:${violation.file}`],
+      title: `Fix pattern violation: ${violation.pattern}`,
+      description: violation.message,
+      files: [violation.file],
+      steps: [violation.suggestion || "Follow pattern guidelines"],
+      whyManual: "Pattern violations often require architectural decisions"
+    });
+  }
+  return suggestions;
+}
+function generateSuggestions(deadCode, drift, patterns) {
+  const suggestions = [];
+  if (deadCode) {
+    suggestions.push(...generateDeadCodeSuggestions(deadCode));
+  }
+  if (drift) {
+    suggestions.push(...generateDriftSuggestions(drift));
+  }
+  if (patterns) {
+    suggestions.push(...generatePatternSuggestions(patterns));
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  suggestions.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  const byPriority = {
+    high: suggestions.filter((s) => s.priority === "high"),
+    medium: suggestions.filter((s) => s.priority === "medium"),
+    low: suggestions.filter((s) => s.priority === "low")
+  };
+  let estimatedEffort;
+  if (suggestions.length === 0) {
+    estimatedEffort = "trivial";
+  } else if (suggestions.length <= 5) {
+    estimatedEffort = "small";
+  } else if (suggestions.length <= 20) {
+    estimatedEffort = "medium";
+  } else {
+    estimatedEffort = "large";
+  }
+  return {
+    suggestions,
+    byPriority,
+    estimatedEffort
+  };
+}
+var TS_HINTS, TS_CONVENTIONS, PYTHON_HINTS, PYTHON_CONVENTIONS, DEFAULT_INCLUDE_PATTERNS, CODE_BLOCK_LANGUAGES, DEFAULT_DRIFT_CONFIG, JS_EXT_FALLBACKS2, FILE_TYPES, EXPORT_TYPES, CONVENTION_DESCRIPTIONS, RULE_CHECKERS, EntropyAnalyzer;
+var init_chunk_BTUDWWB4 = __esm({
+  "../core/dist/chunk-BTUDWWB4.mjs"() {
+    "use strict";
+    init_chunk_MUWJHO2S();
+    init_dist2();
+    init_dist2();
+    TS_HINTS = ['Add "exports" or "main" to package.json', "Create src/index.ts"];
+    TS_CONVENTIONS = ["src/index.ts", "src/main.ts", "src/index.tsx", "index.ts", "main.ts"];
+    PYTHON_HINTS = [
+      "Add an entry to [project.scripts] in pyproject.toml",
+      "Create main.py or <package>/__main__.py"
+    ];
+    PYTHON_CONVENTIONS = [
+      "__main__.py",
+      "main.py",
+      "app.py",
+      "src/__main__.py",
+      "src/main.py",
+      "src/app.py"
+    ];
+    DEFAULT_INCLUDE_PATTERNS = [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.mjs",
+      "**/*.cjs",
+      "**/*.py",
+      "**/*.go",
+      "**/*.rs",
+      "**/*.java"
+    ];
+    CODE_BLOCK_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "ts", "javascript", "js"]);
+    DEFAULT_DRIFT_CONFIG = {
+      docPaths: [],
+      checkApiSignatures: true,
+      checkExamples: true,
+      checkStructure: true,
+      ignorePatterns: []
+    };
+    JS_EXT_FALLBACKS2 = {
+      ".js": [".ts", ".tsx", ".jsx"],
+      ".jsx": [".tsx"],
+      ".mjs": [".mts"],
+      ".cjs": [".cts"]
+    };
+    FILE_TYPES = /* @__PURE__ */ new Set(["file", "module"]);
+    EXPORT_TYPES = /* @__PURE__ */ new Set(["function", "class", "method", "interface", "variable"]);
+    CONVENTION_DESCRIPTIONS = {
+      camelCase: "camelCase (e.g., myFunction)",
+      PascalCase: "PascalCase (e.g., MyClass)",
+      UPPER_SNAKE: "UPPER_SNAKE_CASE (e.g., MY_CONSTANT)",
+      "kebab-case": "kebab-case (e.g., my-component)"
+    };
+    RULE_CHECKERS = {
+      "must-export": checkMustExport,
+      "must-export-default": checkMustExportDefault,
+      "no-export": checkNoExport,
+      "must-import": checkMustImport,
+      "no-import": checkNoImport,
+      naming: checkNaming,
+      "max-exports": checkMaxExports,
+      "max-lines": checkMaxLines,
+      "require-jsdoc": checkRequireJsdoc
+    };
+    EntropyAnalyzer = class {
+      config;
+      snapshot;
+      report;
+      constructor(config) {
+        this.config = { ...config };
+      }
+      /**
+       * Run full entropy analysis.
+       * When graphOptions is provided, passes graph data to drift and dead code detectors
+       * for graph-enhanced analysis instead of snapshot-based analysis.
+       */
+      async analyze(graphOptions) {
+        const startTime = Date.now();
+        const needsSnapshot = !graphOptions || !graphOptions.graphDriftData || !graphOptions.graphDeadCodeData;
+        if (needsSnapshot) {
+          const snapshotResult = await buildSnapshot(this.config);
+          if (!snapshotResult.ok) {
+            return Err(snapshotResult.error);
+          }
+          this.snapshot = snapshotResult.value;
+        } else {
+          this.snapshot = {
+            files: [],
+            dependencyGraph: { nodes: [], edges: [] },
+            exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
+            docs: [],
+            codeReferences: [],
+            entryPoints: [],
+            rootDir: this.config.rootDir,
+            config: this.config,
+            buildTime: 0
+          };
+        }
+        let driftReport;
+        let deadCodeReport;
+        let patternReport;
+        const analysisErrors = [];
+        if (this.config.analyze.drift) {
+          const driftConfig = typeof this.config.analyze.drift === "object" ? this.config.analyze.drift : {};
+          const result = await detectDocDrift(this.snapshot, driftConfig, graphOptions?.graphDriftData);
+          if (result.ok) {
+            driftReport = result.value;
+          } else {
+            analysisErrors.push({ analyzer: "drift", error: result.error });
+          }
+        }
+        if (this.config.analyze.deadCode) {
+          const result = await detectDeadCode(
+            this.snapshot,
+            graphOptions?.graphDeadCodeData,
+            this.config.protectedRegions
+          );
+          if (result.ok) {
+            deadCodeReport = result.value;
+          } else {
+            analysisErrors.push({ analyzer: "deadCode", error: result.error });
+          }
+        }
+        if (this.config.analyze.patterns) {
+          const patternConfig = typeof this.config.analyze.patterns === "object" ? this.config.analyze.patterns : { patterns: [] };
+          const result = await detectPatternViolations(this.snapshot, patternConfig);
+          if (result.ok) {
+            patternReport = result.value;
+          } else {
+            analysisErrors.push({ analyzer: "patterns", error: result.error });
+          }
+        }
+        let complexityReport;
+        if (this.config.analyze.complexity) {
+          const complexityConfig = typeof this.config.analyze.complexity === "object" ? this.config.analyze.complexity : {};
+          const result = await detectComplexityViolations(
+            this.snapshot,
+            complexityConfig,
+            graphOptions?.graphComplexityData
+          );
+          if (result.ok) {
+            complexityReport = result.value;
+          } else {
+            analysisErrors.push({ analyzer: "complexity", error: result.error });
+          }
+        }
+        let couplingReport;
+        if (this.config.analyze.coupling) {
+          const couplingConfig = typeof this.config.analyze.coupling === "object" ? this.config.analyze.coupling : {};
+          const result = await detectCouplingViolations(
+            this.snapshot,
+            couplingConfig,
+            graphOptions?.graphCouplingData
+          );
+          if (result.ok) {
+            couplingReport = result.value;
+          } else {
+            analysisErrors.push({ analyzer: "coupling", error: result.error });
+          }
+        }
+        let sizeBudgetReport;
+        if (this.config.analyze.sizeBudget) {
+          const sizeBudgetConfig = typeof this.config.analyze.sizeBudget === "object" ? this.config.analyze.sizeBudget : {};
+          const result = await detectSizeBudgetViolations(this.config.rootDir, sizeBudgetConfig);
+          if (result.ok) {
+            sizeBudgetReport = result.value;
+          } else {
+            analysisErrors.push({ analyzer: "sizeBudget", error: result.error });
+          }
+        }
+        const driftIssues = driftReport?.drifts.length || 0;
+        const deadCodeIssues = (deadCodeReport?.deadExports.length || 0) + (deadCodeReport?.deadFiles.length || 0) + (deadCodeReport?.unusedImports.length || 0);
+        const patternIssues = patternReport?.violations.length || 0;
+        const patternErrors = patternReport?.stats.errorCount || 0;
+        const patternWarnings = patternReport?.stats.warningCount || 0;
+        const complexityIssues = complexityReport?.violations.length || 0;
+        const couplingIssues = couplingReport?.violations.length || 0;
+        const sizeBudgetIssues = sizeBudgetReport?.violations.length || 0;
+        const complexityErrors = complexityReport?.stats.errorCount || 0;
+        const complexityWarnings = complexityReport?.stats.warningCount || 0;
+        const couplingWarnings = couplingReport?.stats.warningCount || 0;
+        const sizeBudgetWarnings = sizeBudgetReport?.stats.warningCount || 0;
+        const totalIssues = driftIssues + deadCodeIssues + patternIssues + complexityIssues + couplingIssues + sizeBudgetIssues;
+        const fixableCount = (deadCodeReport?.deadFiles.length || 0) + (deadCodeReport?.unusedImports.length || 0);
+        const suggestions = generateSuggestions(deadCodeReport, driftReport, patternReport);
+        const duration = Date.now() - startTime;
+        const report = {
+          snapshot: this.snapshot,
+          analysisErrors,
+          summary: {
+            totalIssues,
+            errors: patternErrors + complexityErrors,
+            warnings: patternWarnings + driftIssues + complexityWarnings + couplingWarnings + sizeBudgetWarnings,
+            fixableCount,
+            suggestionCount: suggestions.suggestions.length
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          duration
+        };
+        if (driftReport) {
+          report.drift = driftReport;
+        }
+        if (deadCodeReport) {
+          report.deadCode = deadCodeReport;
+        }
+        if (patternReport) {
+          report.patterns = patternReport;
+        }
+        if (complexityReport) {
+          report.complexity = complexityReport;
+        }
+        if (couplingReport) {
+          report.coupling = couplingReport;
+        }
+        if (sizeBudgetReport) {
+          report.sizeBudget = sizeBudgetReport;
+        }
+        this.report = report;
+        return Ok(report);
+      }
+      /**
+       * Get the built snapshot (must call analyze first)
+       */
+      getSnapshot() {
+        return this.snapshot;
+      }
+      /**
+       * Get the last report (must call analyze first)
+       */
+      getReport() {
+        return this.report;
+      }
+      /**
+       * Generate suggestions from the last analysis
+       */
+      getSuggestions() {
+        if (!this.report) {
+          return {
+            suggestions: [],
+            byPriority: { high: [], medium: [], low: [] },
+            estimatedEffort: "trivial"
+          };
+        }
+        return generateSuggestions(this.report.deadCode, this.report.drift, this.report.patterns);
+      }
+      /**
+       * Build snapshot without running analysis
+       */
+      async buildSnapshot() {
+        const result = await buildSnapshot(this.config);
+        if (result.ok) {
+          this.snapshot = result.value;
+        }
+        return result;
+      }
+      /**
+       * Ensure snapshot is built, returning the snapshot or an error
+       */
+      async ensureSnapshot() {
+        if (this.snapshot) {
+          return Ok(this.snapshot);
+        }
+        return this.buildSnapshot();
+      }
+      /**
+       * Run drift detection only (snapshot must be built first)
+       */
+      async detectDrift(config, graphDriftData) {
+        const snapshotResult = await this.ensureSnapshot();
+        if (!snapshotResult.ok) {
+          return Err(snapshotResult.error);
+        }
+        return detectDocDrift(snapshotResult.value, config || {}, graphDriftData);
+      }
+      /**
+       * Run dead code detection only (snapshot must be built first)
+       */
+      async detectDeadCode(graphDeadCodeData) {
+        const snapshotResult = await this.ensureSnapshot();
+        if (!snapshotResult.ok) {
+          return Err(snapshotResult.error);
+        }
+        return detectDeadCode(snapshotResult.value, graphDeadCodeData, this.config.protectedRegions);
+      }
+      /**
+       * Run pattern detection only (snapshot must be built first)
+       */
+      async detectPatterns(config) {
+        const snapshotResult = await this.ensureSnapshot();
+        if (!snapshotResult.ok) {
+          return Err(snapshotResult.error);
+        }
+        return detectPatternViolations(snapshotResult.value, config);
+      }
+    };
+  }
+});
+
+export {
+  createError,
+  createEntropyError,
+  createParseError,
+  fileExists,
+  readFileContent,
+  findFiles,
+  relativePosix,
+  TypeScriptParser,
+  EXTENSION_MAP,
+  detectLanguage,
+  getParser,
+  parseFile,
+  resetParserCache,
+  getOutline,
+  formatOutline,
+  defineLayer,
+  resolveFileToLayer,
+  buildDependencyGraph,
+  validateDependencies,
+  detectComplexityViolations,
+  detectCouplingViolations,
+  getDefaultRegistry,
+  init_chunk_MUWJHO2S,
+  buildSnapshot,
+  detectDocDrift,
+  detectDeadCode,
+  detectPatternViolations,
+  parseSize,
+  detectSizeBudgetViolations,
+  generateSuggestions,
+  EntropyAnalyzer,
+  init_chunk_BTUDWWB4
+};