@route-intelligence/core 2.1.0

package/dist/index.js

@@ -0,0 +1,1495 @@
+import {
+  computeMetrics,
+  detectInfiniteRedirects,
+  findCycles,
+  findDeadRoutes,
+  findShortestPath,
+  getMostConnected,
+  metricsToMetadata
+} from "./chunk-56XSRN7B.js";
+
+// src/analyzer.ts
+import { EventEmitter } from "events";
+import { defineConfig } from "@route-intelligence/shared";
+import chokidar from "chokidar";
+
+// src/export/DotExporter.ts
+function exportDot(graph) {
+  const lines = ["digraph RouteGraph {", "  rankdir=LR;", "  node [shape=box];"];
+  for (const nodeId of graph.getAllNodeIds()) {
+    const node = graph.getNode(nodeId);
+    if (!node) continue;
+    lines.push(`  "${escapeDot(nodeId)}" [label="${escapeDot(`${node.type}\\n${node.path}`)}"];`);
+  }
+  for (const edge of graph.getAllEdges()) {
+    const attrs = graph.getUnderlyingGraph().getEdgeAttributes(edge.id);
+    lines.push(
+      `  "${escapeDot(edge.source)}" -> "${escapeDot(edge.target)}" [label="${attrs.type}"];`
+    );
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function escapeDot(s) {
+  return s.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+
+// src/export/MermaidExporter.ts
+function exportMermaid(graph) {
+  const tree = buildPathTree(graph);
+  const lines = ['%%{init: {"flowchart": {"defaultRenderer": "elk"}}}%%', "flowchart LR"];
+  const declaredIds = /* @__PURE__ */ new Set();
+  emitPathTree(tree, null, lines, declaredIds);
+  for (const edge of graph.getAllEdges()) {
+    const attrs = graph.getUnderlyingGraph().getEdgeAttributes(edge.id);
+    if (attrs.type === "layout-parent" || edge.source === edge.target) continue;
+    const sourceId = graphNodeToSegmentId(graph, edge.source);
+    const targetId = graphNodeToSegmentId(graph, edge.target);
+    if (!sourceId || !targetId || !declaredIds.has(sourceId) || !declaredIds.has(targetId)) {
+      continue;
+    }
+    lines.push(`  ${sourceId} -.->|${attrs.type}| ${targetId}`);
+  }
+  return lines.join("\n");
+}
+function graphNodeToSegmentId(graph, nodeId) {
+  const node = graph.getNode(nodeId);
+  if (!node) return void 0;
+  const segments = parsePathSegments(node.path);
+  if (segments.length === 0) return "seg_root";
+  return segmentNodeId(`/${segments.join("/")}`);
+}
+function buildPathTree(graph) {
+  const root = {
+    segment: null,
+    segmentPath: "/",
+    attachedNodes: [],
+    children: /* @__PURE__ */ new Map()
+  };
+  for (const nodeId of graph.getAllNodeIds()) {
+    const node = graph.getNode(nodeId);
+    if (!node) continue;
+    const segments = parsePathSegments(node.path);
+    let current = root;
+    for (const segment of segments) {
+      let child = current.children.get(segment);
+      if (!child) {
+        const segmentPath = current.segmentPath === "/" ? `/${segment}` : `${current.segmentPath}/${segment}`;
+        child = {
+          segment,
+          segmentPath,
+          attachedNodes: [],
+          children: /* @__PURE__ */ new Map()
+        };
+        current.children.set(segment, child);
+      }
+      current = child;
+    }
+    current.attachedNodes.push({
+      graphNodeId: nodeId,
+      type: node.type,
+      path: node.path
+    });
+  }
+  return root;
+}
+function emitPathTree(node, parentId, lines, declaredIds, indent = "  ") {
+  const id = segmentNodeId(node.segmentPath);
+  declareSegmentNode(node, id, lines, declaredIds, indent);
+  if (parentId) {
+    lines.push(`${indent}${parentId} --> ${id}`);
+  }
+  const children = sortPathTreeChildren(node.children);
+  if (children.length === 0) {
+    return id;
+  }
+  if (children.length === 1) {
+    const [onlyChild] = children;
+    if (onlyChild) {
+      emitPathTree(onlyChild, id, lines, declaredIds, indent);
+    }
+    return id;
+  }
+  const subgraphId = `sg_${sanitizeId(node.segmentPath)}`;
+  const subgraphTitle = node.segment ? `${node.segment}/` : "/";
+  lines.push(`${indent}subgraph ${subgraphId}["${escapeLabel(subgraphTitle)}"]`);
+  for (const child of children) {
+    emitPathTree(child, id, lines, declaredIds, `${indent}  `);
+  }
+  lines.push(`${indent}end`);
+  return id;
+}
+function declareSegmentNode(node, id, lines, declaredIds, indent) {
+  if (declaredIds.has(id)) return;
+  declaredIds.add(id);
+  lines.push(`${indent}${id}["${escapeLabel(formatSegmentLabel(node))}"]`);
+}
+function formatSegmentLabel(node) {
+  const parts = [];
+  if (node.segment === null) {
+    parts.push("/");
+  } else {
+    parts.push(node.segment);
+  }
+  for (const attached of node.attachedNodes) {
+    parts.push(formatAttachedLabel(attached, node.segmentPath));
+  }
+  return parts.join("<br/>");
+}
+function formatAttachedLabel(node, segmentPath) {
+  const hashIndex = node.path.indexOf("#");
+  const suffix = hashIndex >= 0 ? node.path.slice(hashIndex) : "";
+  const urlPath = hashIndex >= 0 ? node.path.slice(0, hashIndex) : node.path;
+  if (suffix) {
+    return `${node.type} ${suffix}`;
+  }
+  if (urlPath === segmentPath) {
+    return node.type;
+  }
+  if (segmentPath === "/" && urlPath === "/") {
+    return node.type;
+  }
+  const relative = urlPath.startsWith(`${segmentPath}/`) ? urlPath.slice(segmentPath.length + 1) : urlPath;
+  return `${node.type}: ${relative}`;
+}
+function parsePathSegments(path) {
+  const urlPart = path.split("#")[0] ?? path;
+  if (urlPart === "/" || urlPart === "") return [];
+  return urlPart.split("/").filter(Boolean);
+}
+function segmentNodeId(segmentPath) {
+  if (segmentPath === "/") return "seg_root";
+  const segments = parsePathSegments(segmentPath);
+  return `seg_${segments.map((segment) => sanitizeSegmentForId(segment)).join("__")}`;
+}
+function sanitizeSegmentForId(segment) {
+  const sanitized = segment.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return sanitized || "wildcard";
+}
+function sortPathTreeChildren(children) {
+  return [...children.values()].sort((a, b) => (a.segment ?? "").localeCompare(b.segment ?? ""));
+}
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function escapeLabel(label) {
+  return label.replace(/"/g, '\\"');
+}
+
+// src/export/HtmlExporter.ts
+function exportHtml(graph, root) {
+  const json = JSON.stringify(graph.toJSON(root));
+  const mermaid = exportMermaid(graph);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Route Intelligence Report</title>
+  <script type="module">
+    import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+    mermaid.initialize({
+      startOnLoad: true,
+      theme: 'dark',
+      flowchart: { htmlLabels: true, padding: 12, nodeSpacing: 40, rankSpacing: 55 },
+    });
+  </script>
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 0; padding: 2rem; background: #0a0a0a; color: #fafafa; }
+    h1 { margin-bottom: 0.5rem; }
+    .meta { color: #888; margin-bottom: 2rem; }
+    pre { background: #1a1a1a; padding: 1rem; border-radius: 8px; overflow: auto; }
+    .mermaid { background: #1a1a1a; padding: 1rem; border-radius: 8px; }
+  </style>
+</head>
+<body>
+  <h1>Route Intelligence Report</h1>
+  <p class="meta">Generated from ${root}</p>
+  <h2>Route Graph</h2>
+  <pre class="mermaid">${escapeHtml(mermaid)}</pre>
+  <h2>Graph Data</h2>
+  <pre id="graph-data"></pre>
+  <script>
+    document.getElementById('graph-data').textContent = JSON.stringify(${json}, null, 2);
+  </script>
+</body>
+</html>`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function exportMarkdown(graph, root) {
+  const metadata = graph.toJSON(root).metadata;
+  const lines = [
+    "# Route Intelligence Report",
+    "",
+    `**Root:** \`${root}\``,
+    "",
+    "## Summary",
+    "",
+    `- Routes: ${metadata?.totalRoutes ?? 0}`,
+    `- Layouts: ${metadata?.totalLayouts ?? 0}`,
+    `- API Routes: ${metadata?.totalApiRoutes ?? 0}`,
+    `- Dead Routes: ${metadata?.deadRouteCount ?? 0}`,
+    `- Cycles: ${metadata?.cycleCount ?? 0}`,
+    "",
+    "## Routes",
+    ""
+  ];
+  for (const nodeId of graph.getAllNodeIds()) {
+    const node = graph.getNode(nodeId);
+    if (!node || node.type !== "route") continue;
+    lines.push(`- \`${node.path}\` \u2014 ${node.filePath}${node.isDead ? " *(dead)*" : ""}`);
+  }
+  lines.push("", "## Mermaid Diagram", "", "```mermaid", exportMermaid(graph), "```");
+  return lines.join("\n");
+}
+
+// src/export/JsonExporter.ts
+function exportJson(graph, root) {
+  return JSON.stringify(graph.toJSON(root), null, 2);
+}
+
+// src/export/PlantUMLExporter.ts
+function exportPlantUML(graph) {
+  const lines = ["@startuml", "skinparam componentStyle rectangle"];
+  for (const nodeId of graph.getAllNodeIds()) {
+    const node = graph.getNode(nodeId);
+    if (!node) continue;
+    lines.push(`component "${node.type}\\n${node.path}" as ${sanitizeId2(nodeId)}`);
+  }
+  for (const edge of graph.getAllEdges()) {
+    const attrs = graph.getUnderlyingGraph().getEdgeAttributes(edge.id);
+    lines.push(`${sanitizeId2(edge.source)} --> ${sanitizeId2(edge.target)} : ${attrs.type}`);
+  }
+  lines.push("@enduml");
+  return lines.join("\n");
+}
+function sanitizeId2(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+// src/graph/RouteGraph.ts
+import { MultiDirectedGraph } from "graphology";
+var RouteGraph = class _RouteGraph {
+  graph;
+  constructor() {
+    this.graph = new MultiDirectedGraph({ allowSelfLoops: true });
+  }
+  hasNode(id) {
+    return this.graph.hasNode(id);
+  }
+  getNode(id) {
+    if (!this.graph.hasNode(id)) return void 0;
+    return this.graph.getNodeAttributes(id);
+  }
+  getNodePath(id) {
+    return this.getNode(id)?.path;
+  }
+  findNodeByPath(path) {
+    for (const nodeId of this.graph.nodes()) {
+      const attrs = this.graph.getNodeAttributes(nodeId);
+      if (attrs.path === path) return nodeId;
+    }
+    return void 0;
+  }
+  findNodesByType(type) {
+    return this.graph.filterNodes((_, attrs) => attrs.type === type);
+  }
+  addNode(id, attributes) {
+    if (this.graph.hasNode(id)) {
+      this.graph.mergeNodeAttributes(id, attributes);
+      return;
+    }
+    this.graph.addNode(id, attributes);
+  }
+  removeNode(id) {
+    if (this.graph.hasNode(id)) {
+      this.graph.dropNode(id);
+    }
+  }
+  addEdge(id, source, target, attributes) {
+    if (!this.graph.hasNode(source) || !this.graph.hasNode(target)) return;
+    if (this.graph.hasEdge(id)) {
+      this.graph.mergeEdgeAttributes(id, attributes);
+      return;
+    }
+    this.graph.addEdgeWithKey(id, source, target, attributes);
+  }
+  removeEdge(id) {
+    if (this.graph.hasEdge(id)) {
+      this.graph.dropEdge(id);
+    }
+  }
+  getAllNodeIds() {
+    return this.graph.nodes();
+  }
+  getAllEdges() {
+    return this.graph.mapEdges((edge, attrs, source, target) => ({
+      id: edge,
+      source,
+      target
+    }));
+  }
+  getIncomingEdges(nodeId) {
+    if (!this.graph.hasNode(nodeId)) return [];
+    return this.graph.inEdges(nodeId).map((edgeId) => ({
+      id: edgeId,
+      source: this.graph.source(edgeId),
+      attributes: this.graph.getEdgeAttributes(edgeId)
+    }));
+  }
+  getOutgoingEdges(nodeId) {
+    if (!this.graph.hasNode(nodeId)) return [];
+    return this.graph.outEdges(nodeId).map((edgeId) => ({
+      id: edgeId,
+      target: this.graph.target(edgeId),
+      attributes: this.graph.getEdgeAttributes(edgeId)
+    }));
+  }
+  getUnderlyingGraph() {
+    return this.graph;
+  }
+  toJSON(root, metadata) {
+    const nodes = this.graph.nodes().map((id) => ({
+      id,
+      attributes: this.graph.getNodeAttributes(id)
+    }));
+    const edges = this.graph.edges().map((id) => ({
+      id,
+      source: this.graph.source(id),
+      target: this.graph.target(id),
+      attributes: this.graph.getEdgeAttributes(id)
+    }));
+    return {
+      version: "1.0",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      root,
+      nodes,
+      edges,
+      metadata
+    };
+  }
+  static fromJSON(data) {
+    const graph = new _RouteGraph();
+    for (const node of data.nodes) {
+      graph.addNode(node.id, node.attributes);
+    }
+    for (const edge of data.edges) {
+      graph.addEdge(edge.id, edge.source, edge.target, edge.attributes);
+    }
+    return graph;
+  }
+};
+
+// src/incremental/IncrementalCache.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var IncrementalCache = class {
+  fileHashes = /* @__PURE__ */ new Map();
+  fileDependencies = /* @__PURE__ */ new Map();
+  parsedFiles = /* @__PURE__ */ new Map();
+  graphSnapshot = null;
+  cacheDir;
+  constructor(cacheDir) {
+    this.cacheDir = cacheDir;
+    this.load();
+  }
+  hashFile(content) {
+    return createHash("sha256").update(content).digest("hex");
+  }
+  getFileHash(filePath) {
+    return this.fileHashes.get(filePath);
+  }
+  setFileHash(filePath, hash) {
+    this.fileHashes.set(filePath, hash);
+  }
+  getDependencies(filePath) {
+    return this.fileDependencies.get(filePath) ?? /* @__PURE__ */ new Set();
+  }
+  setDependencies(filePath, nodeIds) {
+    this.fileDependencies.set(filePath, nodeIds);
+  }
+  getParsedFile(filePath) {
+    return this.parsedFiles.get(filePath);
+  }
+  setParsedFile(filePath, file) {
+    this.parsedFiles.set(filePath, file);
+  }
+  getGraphSnapshot() {
+    return this.graphSnapshot;
+  }
+  setGraphSnapshot(snapshot) {
+    this.graphSnapshot = snapshot;
+  }
+  invalidate(filePath) {
+    const nodeIds = [...this.fileDependencies.get(filePath) ?? []];
+    this.parsedFiles.delete(filePath);
+    this.fileHashes.delete(filePath);
+    this.fileDependencies.delete(filePath);
+    return { files: [filePath], nodeIds };
+  }
+  save() {
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+    const data = {
+      fileHashes: Object.fromEntries(this.fileHashes),
+      fileDependencies: Object.fromEntries(
+        [...this.fileDependencies.entries()].map(([k, v]) => [k, [...v]])
+      ),
+      graphSnapshot: this.graphSnapshot ?? void 0
+    };
+    writeFileSync(join(this.cacheDir, "cache.json"), JSON.stringify(data, null, 2));
+  }
+  load() {
+    const cachePath = join(this.cacheDir, "cache.json");
+    if (!existsSync(cachePath)) return;
+    try {
+      const data = JSON.parse(readFileSync(cachePath, "utf-8"));
+      this.fileHashes = new Map(Object.entries(data.fileHashes));
+      this.fileDependencies = new Map(
+        Object.entries(data.fileDependencies).map(([k, v]) => [k, new Set(v)])
+      );
+      this.graphSnapshot = data.graphSnapshot ?? null;
+    } catch {
+    }
+  }
+};
+function computeGraphPatch(before, after) {
+  const beforeNodeIds = new Set(before.nodes.map((n) => n.id));
+  const afterNodeIds = new Set(after.nodes.map((n) => n.id));
+  const beforeEdgeIds = new Set(before.edges.map((e) => e.id));
+  const afterEdgeIds = new Set(after.edges.map((e) => e.id));
+  return {
+    addedNodes: after.nodes.filter((n) => !beforeNodeIds.has(n.id)),
+    removedNodeIds: before.nodes.filter((n) => !afterNodeIds.has(n.id)).map((n) => n.id),
+    addedEdges: after.edges.filter((e) => !beforeEdgeIds.has(e.id)),
+    removedEdgeIds: before.edges.filter((e) => !afterEdgeIds.has(e.id)).map((e) => e.id),
+    modifiedNodeIds: after.nodes.filter((n) => {
+      if (!beforeNodeIds.has(n.id)) return false;
+      const prev = before.nodes.find((bn) => bn.id === n.id);
+      return JSON.stringify(prev?.attributes) !== JSON.stringify(n.attributes);
+    }).map((n) => n.id)
+  };
+}
+function readFileContent(filePath) {
+  return readFileSync(filePath, "utf-8");
+}
+
+// src/incremental/Invalidator.ts
+var Invalidator = class {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  cache;
+  computeInvalidation(event) {
+    if (event.type === "unlink") {
+      return this.cache.invalidate(event.path);
+    }
+    if (event.type === "change" || event.type === "add") {
+      try {
+        const content = readFileContent(event.path);
+        const newHash = this.cache.hashFile(content);
+        const oldHash = this.cache.getFileHash(event.path);
+        if (oldHash === newHash) {
+          return { files: [], nodeIds: [] };
+        }
+        this.cache.setFileHash(event.path, newHash);
+        return this.cache.invalidate(event.path);
+      } catch {
+        return this.cache.invalidate(event.path);
+      }
+    }
+    return { files: [], nodeIds: [] };
+  }
+  getAffectedFiles(invalidation) {
+    return invalidation.files;
+  }
+};
+
+// src/pipeline/stages/FileSystemStage.ts
+import fg from "fast-glob";
+import picomatch from "picomatch";
+var FileSystemStage = class {
+  name = "FileSystemStage";
+  async run(ctx) {
+    const include = ctx.config.include ?? ["**/*.{ts,tsx,js,jsx}"];
+    const exclude = ctx.config.exclude ?? [
+      "**/node_modules/**",
+      "**/.next/**",
+      "**/dist/**",
+      "**/*.test.*",
+      "**/*.spec.*"
+    ];
+    const files = await fg(include, {
+      cwd: ctx.root,
+      absolute: true,
+      ignore: exclude,
+      onlyFiles: true
+    });
+    const isExcluded = picomatch(exclude);
+    ctx.files = files.filter((f) => !isExcluded(f));
+  }
+};
+
+// src/pipeline/stages/NavigationAnalysisStage.ts
+import { createDefaultEdgeAttributes } from "@route-intelligence/shared";
+
+// src/pipeline/types.ts
+function createProjectContext(root, config, pluginConfig = {}) {
+  return { root, config, pluginConfig };
+}
+function createAnalysisContext(ctx, plugin) {
+  const pluginConfig = ctx.pluginConfigs.get(plugin.id) ?? {};
+  return {
+    root: ctx.root,
+    config: ctx.config,
+    pluginConfig,
+    graph: ctx.graph,
+    routes: ctx.routes
+  };
+}
+
+// src/pipeline/stages/NavigationAnalysisStage.ts
+function resolveTargetPath(destination, ctx) {
+  switch (destination.kind) {
+    case "static":
+      return { path: destination.path, isExternal: false };
+    case "template-literal":
+      return { path: destination.template.replace(/\$\{[^}]+\}/g, "[param]"), isExternal: false };
+    case "external":
+      return { isExternal: true };
+    case "dynamic":
+      return { isExternal: false };
+    default: {
+      const _exhaustive = destination;
+      return _exhaustive;
+    }
+  }
+}
+function findSourceNodeId(filePath, ctx) {
+  for (const [id, route] of ctx.routes) {
+    if (route.filePath === filePath) return id;
+  }
+  return void 0;
+}
+function findTargetNodeId(path, ctx) {
+  if (!path) return void 0;
+  return ctx.graph.findNodeByPath(path);
+}
+var NavigationAnalysisStage = class {
+  name = "NavigationAnalysisStage";
+  async run(ctx) {
+    for (const plugin of ctx.plugins) {
+      const analysisCtx = createAnalysisContext(ctx, plugin);
+      for (const [filePath, semanticFile] of ctx.semanticFiles) {
+        const result = await plugin.analyzeFile(semanticFile, analysisCtx);
+        for (const edge of result.edges) {
+          const sourceId = edge.sourceId || findSourceNodeId(filePath, ctx);
+          if (!sourceId) continue;
+          let targetId = edge.targetId;
+          if (!targetId && edge.targetPath) {
+            targetId = findTargetNodeId(edge.targetPath, ctx);
+          }
+          if (!targetId) {
+            const resolved = resolveTargetPath(
+              edge.targetPath ? { kind: "static", path: edge.targetPath } : { kind: "dynamic", expression: "unknown" },
+              ctx
+            );
+            if (resolved.path) {
+              targetId = findTargetNodeId(resolved.path, ctx);
+            }
+          }
+          if (!targetId) continue;
+          const edgeType = edge.conditions.length > 0 ? "conditional-navigation" : edge.type;
+          ctx.graph.addEdge(
+            `nav:${sourceId}->${targetId}:${edge.loc.line}`,
+            sourceId,
+            targetId,
+            createDefaultEdgeAttributes({
+              type: edgeType,
+              source: edge.source,
+              method: edge.method,
+              isExternal: edge.isExternal,
+              conditions: edge.conditions,
+              loc: edge.loc
+            })
+          );
+        }
+      }
+    }
+  }
+};
+var MiddlewareAnalysisStage = class {
+  name = "MiddlewareAnalysisStage";
+  async run(ctx) {
+    for (const plugin of ctx.plugins) {
+      const projectCtx = {
+        root: ctx.root,
+        config: ctx.config,
+        pluginConfig: ctx.pluginConfigs.get(plugin.id) ?? {}
+      };
+      await plugin.enrichGraph(ctx.graph, projectCtx);
+    }
+  }
+};
+var ConditionalAnalysisStage = class {
+  name = "ConditionalAnalysisStage";
+  async run(ctx) {
+    for (const nodeId of ctx.graph.getAllNodeIds()) {
+      const node = ctx.graph.getNode(nodeId);
+      if (!node) continue;
+      const file = ctx.semanticFiles.get(node.filePath);
+      if (!file) continue;
+      const allConditions = file.conditionalBlocks.flatMap((b) => b.conditions);
+      if (allConditions.length > 0) {
+        ctx.graph.addNode(nodeId, {
+          ...node,
+          conditions: [...node.conditions, ...allConditions]
+        });
+      }
+    }
+  }
+};
+var GraphEnrichmentStage = class {
+  name = "GraphEnrichmentStage";
+  async run(ctx) {
+    for (const nodeId of ctx.graph.getAllNodeIds()) {
+      const node = ctx.graph.getNode(nodeId);
+      if (!node) continue;
+      const depth = node.path.split("/").filter(Boolean).length;
+      ctx.graph.addNode(nodeId, { ...node, depth });
+    }
+  }
+};
+
+// src/pipeline/stages/ParseStage.ts
+import { Project } from "ts-morph";
+
+// src/ast/SemanticFile.ts
+import { Node as Node3 } from "ts-morph";
+
+// src/ast/ComponentClassifier.ts
+function isClientComponent(sourceFile) {
+  const statements = sourceFile.getStatements();
+  for (const stmt of statements.slice(0, 5)) {
+    const text = stmt.getText().trim();
+    if (text === "'use client'" || text === '"use client"') return true;
+    if (!text.startsWith("'use ") && !text.startsWith('"use ')) break;
+  }
+  return false;
+}
+function isServerComponent(sourceFile) {
+  return !isClientComponent(sourceFile);
+}
+
+// src/ast/ConditionalVisitor.ts
+import { Node } from "ts-morph";
+function toLoc(node, filePath) {
+  return {
+    filePath,
+    line: node.getStartLineNumber(),
+    column: 1
+  };
+}
+function inferConditionKind(expression) {
+  const lower = expression.toLowerCase();
+  if (lower.includes("auth") || lower.includes("session")) return "auth";
+  if (lower.includes("role")) return "role";
+  if (lower.includes("permission")) return "permission";
+  if (lower.includes("feature") || lower.includes("flag")) return "feature-flag";
+  if (lower.includes("subscription") || lower.includes("plan")) return "subscription";
+  if (lower.includes("cookie")) return "cookie";
+  if (lower.includes("header")) return "header";
+  if (lower.includes("locale")) return "locale";
+  if (lower.includes("process.env")) return "env";
+  if (lower.includes("searchparams")) return "search-param";
+  return "unknown";
+}
+function expressionToConditions(expression, negated = false) {
+  return [
+    {
+      kind: inferConditionKind(expression),
+      expression,
+      negated,
+      confidence: "inferred"
+    }
+  ];
+}
+function extractConditionalBlocks(sourceFile, filePath) {
+  const blocks = [];
+  sourceFile.forEachDescendant((node) => {
+    if (Node.isIfStatement(node)) {
+      const expr = node.getExpression().getText();
+      blocks.push({
+        expression: expr,
+        conditions: expressionToConditions(expr),
+        loc: toLoc(node, filePath)
+      });
+    }
+    if (Node.isSwitchStatement(node)) {
+      const expr = node.getExpression().getText();
+      blocks.push({
+        expression: expr,
+        conditions: expressionToConditions(expr),
+        loc: toLoc(node, filePath)
+      });
+    }
+    if (Node.isConditionalExpression(node)) {
+      const expr = node.getCondition().getText();
+      blocks.push({
+        expression: expr,
+        conditions: expressionToConditions(expr),
+        loc: toLoc(node, filePath)
+      });
+    }
+  });
+  return blocks;
+}
+
+// src/ast/NavigationVisitor.ts
+import {
+  Node as Node2,
+  SyntaxKind
+} from "ts-morph";
+function toLoc2(node, filePath) {
+  const start = node.getStartLineNumber();
+  const col = node.getStart() - node.getSourceFile().getLineAndColumnAtPos(node.getStart()).column;
+  return {
+    filePath,
+    line: start,
+    column: node.getStartLineNumber() > 0 ? 1 : 0
+  };
+}
+function resolveDestination(expr) {
+  if (!expr) return { kind: "dynamic", expression: "unknown" };
+  if (Node2.isStringLiteral(expr) || Node2.isNoSubstitutionTemplateLiteral(expr)) {
+    const path = expr.getLiteralText();
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return { kind: "external", url: path };
+    }
+    return { kind: "static", path };
+  }
+  if (Node2.isTemplateExpression(expr)) {
+    const head = expr.getHead().getLiteralText();
+    const spans = expr.getTemplateSpans();
+    const params = [];
+    let template = head;
+    for (const span of spans) {
+      const paramExpr = span.getExpression();
+      params.push(paramExpr.getText());
+      template += `\${${paramExpr.getText()}}`;
+      template += span.getLiteral().getLiteralText();
+    }
+    return { kind: "template-literal", template, params };
+  }
+  return { kind: "dynamic", expression: expr.getText() };
+}
+var NAVIGATION_CALLEES = /* @__PURE__ */ new Set([
+  "redirect",
+  "permanentRedirect",
+  "push",
+  "replace",
+  "prefetch",
+  "back",
+  "forward"
+]);
+function getCalleeName(call) {
+  const expr = call.getExpression();
+  if (Node2.isIdentifier(expr)) {
+    return expr.getText();
+  }
+  if (Node2.isPropertyAccessExpression(expr)) {
+    const obj = expr.getExpression().getText();
+    const name = expr.getName();
+    if (obj === "router" || obj.endsWith("Router")) {
+      return `router.${name}`;
+    }
+    if (obj === "NextResponse") {
+      return `NextResponse.${name}`;
+    }
+    if (obj === "history") {
+      return `history.${name}`;
+    }
+    if (obj === "window.location") {
+      return "window.location";
+    }
+    return `${obj}.${name}`;
+  }
+  return expr.getText();
+}
+function extractConditionsFromNode(node) {
+  let current = node;
+  const conditions = [];
+  while (current) {
+    const parent = current.getParent();
+    if (!parent) break;
+    if (Node2.isIfStatement(parent)) {
+      conditions.push({
+        kind: inferConditionKind2(parent.getExpression().getText()),
+        expression: parent.getExpression().getText(),
+        negated: parent.getElseStatement() === current,
+        confidence: "inferred"
+      });
+    }
+    if (Node2.isConditionalExpression(parent)) {
+      conditions.push({
+        kind: "unknown",
+        expression: parent.getCondition().getText(),
+        negated: parent.getWhenFalse() === current,
+        confidence: "inferred"
+      });
+    }
+    current = parent;
+  }
+  return conditions;
+}
+function inferConditionKind2(expression) {
+  const lower = expression.toLowerCase();
+  if (lower.includes("auth") || lower.includes("session") || lower.includes("loggedin")) {
+    return "auth";
+  }
+  if (lower.includes("role")) return "role";
+  if (lower.includes("permission")) return "permission";
+  if (lower.includes("feature") || lower.includes("flag")) return "feature-flag";
+  if (lower.includes("cookie")) return "cookie";
+  if (lower.includes("header")) return "header";
+  if (lower.includes("locale") || lower.includes("lang")) return "locale";
+  if (lower.includes("process.env")) return "env";
+  if (lower.includes("searchparams") || lower.includes("query")) return "search-param";
+  return "unknown";
+}
+function extractNavigationCalls(sourceFile, filePath, customWrappers = []) {
+  const calls = [];
+  sourceFile.forEachDescendant((node) => {
+    if (!Node2.isCallExpression(node)) return;
+    const callee = getCalleeName(node);
+    const calleeBase = callee.split(".").pop() ?? callee;
+    const isNavCall = NAVIGATION_CALLEES.has(calleeBase) || callee.startsWith("router.") || callee.startsWith("NextResponse.") || callee.startsWith("history.") || customWrappers.some((w) => callee.includes(w));
+    if (!isNavCall) return;
+    const args = node.getArguments();
+    let destination = { kind: "dynamic", expression: "unknown" };
+    let method;
+    if (calleeBase === "back" || calleeBase === "forward") {
+      destination = { kind: "dynamic", expression: calleeBase };
+    } else if (args[0] && Node2.isExpression(args[0])) {
+      destination = resolveDestination(args[0]);
+    }
+    if (calleeBase === "replace" || callee.includes("permanentRedirect")) {
+      method = "replace";
+    } else if (calleeBase === "push") {
+      method = "push";
+    }
+    calls.push({
+      callee,
+      destination,
+      method,
+      conditions: extractConditionsFromNode(node),
+      loc: toLoc2(node, filePath)
+    });
+  });
+  return calls;
+}
+function extractJsxLinks(sourceFile, filePath) {
+  const links = [];
+  sourceFile.forEachDescendant((node) => {
+    if (!Node2.isJsxOpeningElement(node) && !Node2.isJsxSelfClosingElement(node)) return;
+    const tagName = Node2.isJsxOpeningElement(node) ? node.getTagNameNode().getText() : node.getTagNameNode().getText();
+    if (tagName !== "Link" && !tagName.endsWith(".Link")) return;
+    const hrefAttr = node.getAttribute("href");
+    if (!hrefAttr) return;
+    const initializer = hrefAttr.getInitializer();
+    let destination = { kind: "dynamic", expression: "unknown" };
+    if (initializer && Node2.isJsxExpression(initializer)) {
+      const expr = initializer.getExpression();
+      if (expr) destination = resolveDestination(expr);
+    } else if (initializer && Node2.isStringLiteral(initializer)) {
+      destination = resolveDestination(initializer);
+    }
+    const prefetchAttr = node.getAttribute("prefetch");
+    let prefetch;
+    if (prefetchAttr && Node2.isJsxAttribute(prefetchAttr)) {
+      const init = prefetchAttr.getInitializer();
+      if (init && Node2.isStringLiteral(init)) {
+        prefetch = init.getLiteralText() !== "false";
+      } else {
+        prefetch = true;
+      }
+    }
+    links.push({
+      componentName: tagName,
+      destination,
+      prefetch,
+      conditions: extractConditionsFromNode(node),
+      loc: toLoc2(node, filePath)
+    });
+  });
+  return links;
+}
+function extractWindowLocationAssignments(sourceFile, filePath) {
+  const calls = [];
+  sourceFile.forEachDescendant((node) => {
+    if (!Node2.isBinaryExpression(node)) return;
+    if (node.getOperatorToken().getKind() !== SyntaxKind.EqualsToken) return;
+    const left = node.getLeft().getText();
+    if (!left.includes("window.location") && !left.includes("location.href")) return;
+    calls.push({
+      callee: "window.location",
+      destination: resolveDestination(node.getRight()),
+      method: "replace",
+      conditions: extractConditionsFromNode(node),
+      loc: toLoc2(node, filePath)
+    });
+  });
+  return calls;
+}
+function extractWindowOpenCalls(sourceFile, filePath) {
+  const calls = [];
+  sourceFile.forEachDescendant((node) => {
+    if (!Node2.isCallExpression(node)) return;
+    const callee = getCalleeName(node);
+    if (callee !== "window.open" && callee !== "open") return;
+    const args = node.getArguments();
+    calls.push({
+      callee: "window.open",
+      destination: args[0] && Node2.isExpression(args[0]) ? resolveDestination(args[0]) : { kind: "dynamic", expression: "unknown" },
+      conditions: extractConditionsFromNode(node),
+      loc: toLoc2(node, filePath)
+    });
+  });
+  return calls;
+}
+
+// src/ast/SemanticFile.ts
+function extractImports(sourceFile, filePath) {
+  const imports = [];
+  for (const imp of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = imp.getModuleSpecifierValue();
+    const namedImports = imp.getNamedImports().map((n) => n.getName());
+    const defaultImport = imp.getDefaultImport()?.getText();
+    imports.push({
+      moduleSpecifier,
+      namedImports,
+      defaultImport,
+      loc: { filePath, line: imp.getStartLineNumber(), column: 1 }
+    });
+  }
+  return imports;
+}
+function extractExports(sourceFile, filePath) {
+  const exports = [];
+  for (const [name, decls] of sourceFile.getExportedDeclarations()) {
+    const firstDecl = decls[0];
+    if (firstDecl && typeof firstDecl !== "string" && "getStartLineNumber" in firstDecl) {
+      exports.push({
+        name,
+        isDefault: false,
+        loc: { filePath, line: firstDecl.getStartLineNumber(), column: 1 }
+      });
+    }
+  }
+  const defaultExport = sourceFile.getDefaultExportSymbol();
+  if (defaultExport) {
+    exports.push({
+      name: "default",
+      isDefault: true,
+      loc: { filePath, line: 1, column: 1 }
+    });
+  }
+  return exports;
+}
+function extractComponents(sourceFile, filePath) {
+  const components = [];
+  for (const fn of sourceFile.getFunctions()) {
+    const name = fn.getName();
+    if (name && /^[A-Z]/.test(name)) {
+      components.push({
+        name,
+        isDefault: fn.isDefaultExport(),
+        loc: { filePath, line: fn.getStartLineNumber(), column: 1 }
+      });
+    }
+  }
+  for (const stmt of sourceFile.getVariableStatements()) {
+    for (const decl of stmt.getDeclarations()) {
+      const name = decl.getName();
+      if (/^[A-Z]/.test(name)) {
+        const init = decl.getInitializer();
+        if (init && (Node3.isArrowFunction(init) || Node3.isFunctionExpression(init) || Node3.isCallExpression(init))) {
+          components.push({
+            name,
+            isDefault: stmt.isDefaultExport(),
+            loc: { filePath, line: decl.getStartLineNumber(), column: 1 }
+          });
+        }
+      }
+    }
+  }
+  return components;
+}
+function createSemanticFile(sourceFile, filePath, customNavigationWrappers = []) {
+  const navCalls = [
+    ...extractNavigationCalls(sourceFile, filePath, customNavigationWrappers),
+    ...extractWindowLocationAssignments(sourceFile, filePath),
+    ...extractWindowOpenCalls(sourceFile, filePath)
+  ];
+  const jsxLinks = extractJsxLinks(sourceFile, filePath);
+  const conditionalBlocks = extractConditionalBlocks(sourceFile, filePath);
+  const imports = extractImports(sourceFile, filePath);
+  const exports = extractExports(sourceFile, filePath);
+  const components = extractComponents(sourceFile, filePath);
+  const client = isClientComponent(sourceFile);
+  const server = isServerComponent(sourceFile);
+  return {
+    path: filePath,
+    get isClientComponent() {
+      return client;
+    },
+    get isServerComponent() {
+      return server;
+    },
+    get exports() {
+      return exports;
+    },
+    get imports() {
+      return imports;
+    },
+    get components() {
+      return components;
+    },
+    get navigationCalls() {
+      return navCalls;
+    },
+    get jsxLinks() {
+      return jsxLinks;
+    },
+    get conditionalBlocks() {
+      return conditionalBlocks;
+    },
+    sourceFile
+  };
+}
+
+// src/pipeline/stages/ParseStage.ts
+var ParseStage = class {
+  name = "ParseStage";
+  project = null;
+  async run(ctx) {
+    if (!this.project) {
+      this.project = new Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+          allowJs: true,
+          jsx: 4
+        }
+      });
+    }
+    const customWrappers = this.getCustomWrappers(ctx);
+    for (const filePath of ctx.files) {
+      if (!/\.(tsx?|jsx?)$/.test(filePath)) continue;
+      try {
+        let sourceFile = this.project.getSourceFile(filePath);
+        if (!sourceFile) {
+          sourceFile = this.project.addSourceFileAtPath(filePath);
+        }
+        ctx.semanticFiles.set(filePath, createSemanticFile(sourceFile, filePath, customWrappers));
+      } catch {
+      }
+    }
+  }
+  getCustomWrappers(ctx) {
+    const wrappers = [];
+    for (const config of ctx.pluginConfigs.values()) {
+      const custom = config.customNavigationWrappers;
+      if (Array.isArray(custom)) {
+        wrappers.push(...custom);
+      }
+    }
+    return wrappers;
+  }
+};
+
+// src/pipeline/stages/RouteDiscoveryStage.ts
+import {
+  createDefaultEdgeAttributes as createDefaultEdgeAttributes2,
+  createDefaultNodeAttributes
+} from "@route-intelligence/shared";
+var RouteDiscoveryStage = class {
+  name = "RouteDiscoveryStage";
+  async run(ctx) {
+    ctx.routes.clear();
+    for (const plugin of ctx.plugins) {
+      const pluginConfig = ctx.pluginConfigs.get(plugin.id) ?? {};
+      const projectCtx = createProjectContext(ctx.root, ctx.config, pluginConfig);
+      for await (const route of plugin.discoverRoutes(projectCtx)) {
+        ctx.routes.set(route.id, route);
+        ctx.graph.addNode(
+          route.id,
+          createDefaultNodeAttributes({
+            type: route.type,
+            path: route.urlPath,
+            filePath: route.filePath,
+            segment: route.segment,
+            isDynamic: route.isDynamic,
+            isCatchAll: route.isCatchAll,
+            isOptionalCatchAll: route.isOptionalCatchAll,
+            isParallelSlot: route.isParallelSlot,
+            slotName: route.slotName,
+            isIntercepted: route.isIntercepted,
+            interceptLevel: route.interceptLevel,
+            isRouteGroup: route.isRouteGroup,
+            groupName: route.groupName,
+            isClientComponent: false,
+            isServerComponent: true,
+            tags: route.tags,
+            loc: { filePath: route.filePath, line: 1, column: 1 }
+          })
+        );
+      }
+    }
+  }
+};
+var GraphBuildStage = class {
+  name = "GraphBuildStage";
+  async run(ctx) {
+    for (const route of ctx.routes.values()) {
+      if (route.parentLayoutId && ctx.graph.hasNode(route.parentLayoutId)) {
+        ctx.graph.addEdge(
+          `layout-parent:${route.parentLayoutId}->${route.id}`,
+          route.parentLayoutId,
+          route.id,
+          createDefaultEdgeAttributes2({
+            type: "layout-parent",
+            source: "unknown"
+          })
+        );
+      }
+      if (route.parentTemplateId && ctx.graph.hasNode(route.parentTemplateId)) {
+        ctx.graph.addEdge(
+          `template-parent:${route.parentTemplateId}->${route.id}`,
+          route.parentTemplateId,
+          route.id,
+          createDefaultEdgeAttributes2({
+            type: "template-parent",
+            source: "unknown"
+          })
+        );
+      }
+    }
+  }
+};
+
+// src/pipeline/stages/SemanticStage.ts
+var SemanticStage = class {
+  name = "SemanticStage";
+  async run(_ctx) {
+  }
+};
+
+// src/pipeline/stages/StaticAnalysisStage.ts
+var StaticAnalysisStage = class {
+  name = "StaticAnalysisStage";
+  async run(ctx) {
+    const diagnostics = [];
+    diagnostics.push(...this.checkDeadRoutes(ctx));
+    diagnostics.push(...this.checkBrokenLinks(ctx));
+    diagnostics.push(...this.checkRedirectCycles(ctx));
+    diagnostics.push(...this.checkCircularNavigation(ctx));
+    diagnostics.push(...this.checkDuplicateRoutes(ctx));
+    diagnostics.push(...this.checkOpenRedirects(ctx));
+    for (const plugin of ctx.plugins) {
+      const projectCtx = createProjectContext(
+        ctx.root,
+        ctx.config,
+        ctx.pluginConfigs.get(plugin.id) ?? {}
+      );
+      const pluginDiags = await plugin.runDiagnostics(ctx.graph);
+      diagnostics.push(...pluginDiags);
+    }
+    for (const diag of diagnostics) {
+      if (diag.nodeId && ctx.graph.hasNode(diag.nodeId)) {
+        const node = ctx.graph.getNode(diag.nodeId);
+        if (node) {
+          ctx.graph.addNode(diag.nodeId, {
+            ...node,
+            diagnostics: [...node.diagnostics, diag],
+            isDead: diag.ruleId === "dead-route" ? true : node.isDead
+          });
+        }
+      }
+    }
+    ctx.diagnostics = diagnostics;
+  }
+  checkDeadRoutes(ctx) {
+    const dead = findDeadRoutes(ctx.graph);
+    return dead.map((nodeId) => {
+      const node = ctx.graph.getNode(nodeId);
+      return {
+        ruleId: "dead-route",
+        severity: "warning",
+        message: `Route "${node?.path ?? nodeId}" appears to be unreachable`,
+        nodeId,
+        loc: node?.loc
+      };
+    });
+  }
+  checkBrokenLinks(ctx) {
+    const diags = [];
+    for (const edge of ctx.graph.getAllEdges()) {
+      const attrs = ctx.graph.getUnderlyingGraph().getEdgeAttributes(edge.id);
+      if (attrs.type !== "navigation" && attrs.type !== "conditional-navigation" && attrs.type !== "prefetch") {
+        continue;
+      }
+      if (attrs.isExternal) continue;
+      const targetNode = ctx.graph.getNode(edge.target);
+      if (!targetNode && !attrs.conditions.some((c) => c.kind === "unknown")) {
+        diags.push({
+          ruleId: "broken-link",
+          severity: "error",
+          message: "Navigation target does not resolve to a known route",
+          edgeId: edge.id,
+          loc: attrs.loc
+        });
+      }
+    }
+    return diags;
+  }
+  checkRedirectCycles(ctx) {
+    const cycles = detectInfiniteRedirects(ctx.graph);
+    return cycles.map((cycle) => ({
+      ruleId: "redirect-cycle",
+      severity: "error",
+      message: `Redirect cycle detected: ${cycle.nodes.join(" -> ")}`,
+      nodeId: cycle.nodes[0]
+    }));
+  }
+  checkCircularNavigation(ctx) {
+    const cycles = findCycles(ctx.graph);
+    return cycles.map((cycle) => ({
+      ruleId: "circular-navigation",
+      severity: "warning",
+      message: `Navigation cycle detected: ${cycle.nodes.join(" -> ")}`,
+      nodeId: cycle.nodes[0]
+    }));
+  }
+  checkDuplicateRoutes(ctx) {
+    const pathMap = /* @__PURE__ */ new Map();
+    for (const nodeId of ctx.graph.getAllNodeIds()) {
+      const node = ctx.graph.getNode(nodeId);
+      if (!node || node.type !== "route") continue;
+      const existing = pathMap.get(node.path) ?? [];
+      existing.push(nodeId);
+      pathMap.set(node.path, existing);
+    }
+    const diags = [];
+    for (const [path, ids] of pathMap) {
+      if (ids.length > 1) {
+        diags.push({
+          ruleId: "duplicate-route",
+          severity: "error",
+          message: `Duplicate route path "${path}" found in ${ids.length} locations`,
+          nodeId: ids[0]
+        });
+      }
+    }
+    return diags;
+  }
+  checkOpenRedirects(ctx) {
+    const diags = [];
+    const redirectTypes = ["redirect", "permanent-redirect"];
+    for (const edge of ctx.graph.getAllEdges()) {
+      const attrs = ctx.graph.getUnderlyingGraph().getEdgeAttributes(edge.id);
+      if (!redirectTypes.includes(attrs.type)) continue;
+      const hasDynamicCondition = attrs.conditions.some(
+        (c) => c.expression.includes("searchParams") || c.expression.includes("query")
+      );
+      if (hasDynamicCondition) {
+        diags.push({
+          ruleId: "open-redirect",
+          severity: "warning",
+          message: "Potential open redirect: destination may be user-controlled",
+          edgeId: edge.id,
+          loc: attrs.loc
+        });
+      }
+    }
+    return diags;
+  }
+};
+var MetricsStage = class {
+  name = "MetricsStage";
+  async run(ctx) {
+    const { metricsToMetadata: metricsToMetadata3 } = await import("./metrics-SMPFGQCR.js");
+    ctx.metadata = metricsToMetadata3(
+      ctx.graph,
+      ctx.plugins.map((p) => p.id)
+    );
+  }
+};
+var OutputStage = class {
+  name = "OutputStage";
+  async run(_ctx) {
+  }
+};
+
+// src/pipeline/Pipeline.ts
+var Pipeline = class {
+  stages;
+  constructor(stages) {
+    this.stages = stages ?? [
+      new FileSystemStage(),
+      new ParseStage(),
+      new SemanticStage(),
+      new RouteDiscoveryStage(),
+      new GraphBuildStage(),
+      new NavigationAnalysisStage(),
+      new MiddlewareAnalysisStage(),
+      new ConditionalAnalysisStage(),
+      new GraphEnrichmentStage(),
+      new StaticAnalysisStage(),
+      new MetricsStage(),
+      new OutputStage()
+    ];
+  }
+  async run(ctx) {
+    for (const stage of this.stages) {
+      await stage.run(ctx);
+    }
+    return {
+      diagnostics: ctx.diagnostics ?? [],
+      metadata: ctx.metadata ?? {
+        pluginIds: ctx.plugins.map((p) => p.id),
+        totalRoutes: 0,
+        totalLayouts: 0,
+        totalApiRoutes: 0,
+        deadRouteCount: 0,
+        cycleCount: 0
+      }
+    };
+  }
+};
+
+// src/plugin/PluginRegistry.ts
+var PluginRegistry = class {
+  plugins = [];
+  register(plugin) {
+    this.plugins.push(plugin);
+  }
+  registerAll(plugins) {
+    for (const plugin of plugins) {
+      this.register(plugin);
+    }
+  }
+  getAll() {
+    return [...this.plugins];
+  }
+  async detectActive(root, config) {
+    const active = [];
+    for (const plugin of this.plugins) {
+      const ctx = { root, config, pluginConfig: {} };
+      if (await plugin.detect(ctx)) {
+        active.push(plugin);
+      }
+    }
+    return active;
+  }
+};
+
+// src/analyzer.ts
+var RouteAnalyzer = class {
+  constructor(config) {
+    this.config = config;
+    this.registry.registerAll(config.plugins);
+  }
+  config;
+  registry = new PluginRegistry();
+  async analyze() {
+    const plugins = await this.registry.detectActive(this.config.root, this.config);
+    const graph = new RouteGraph();
+    const ctx = {
+      root: this.config.root,
+      config: this.config,
+      graph,
+      plugins,
+      files: [],
+      semanticFiles: /* @__PURE__ */ new Map(),
+      routes: /* @__PURE__ */ new Map(),
+      pluginConfigs: /* @__PURE__ */ new Map()
+    };
+    for (const plugin of plugins) {
+      const projectCtx = { root: this.config.root, config: this.config, pluginConfig: {} };
+      const pluginConfig = await plugin.configure(projectCtx);
+      ctx.pluginConfigs.set(plugin.id, pluginConfig);
+    }
+    const pipeline = new Pipeline();
+    const { diagnostics, metadata } = await pipeline.run(ctx);
+    return { graph, diagnostics, metadata };
+  }
+  watch() {
+    const emitter = new EventEmitter();
+    const cacheDir = this.config.cache?.directory ?? ".route-intelligence";
+    const cache = new IncrementalCache(cacheDir);
+    const invalidator = new Invalidator(cache);
+    let previousSnapshot = cache.getGraphSnapshot();
+    let watcher = null;
+    const runAnalysis = async () => {
+      try {
+        const result = await this.analyze();
+        const routeGraph = result.graph;
+        const snapshot = routeGraph.toJSON(this.config.root, result.metadata);
+        cache.setGraphSnapshot(snapshot);
+        cache.save();
+        if (previousSnapshot) {
+          const patch = computeGraphPatch(previousSnapshot, snapshot);
+          emitter.emit("update", patch);
+        }
+        previousSnapshot = snapshot;
+      } catch (error) {
+        emitter.emit("error", error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    watcher = chokidar.watch(this.config.root, {
+      ignored: this.config.exclude ?? ["**/node_modules/**", "**/.next/**"],
+      ignoreInitial: true
+    });
+    watcher.on("all", async (event, path) => {
+      const type = event === "add" ? "add" : event === "unlink" ? "unlink" : "change";
+      invalidator.computeInvalidation({ type, path });
+      await runAnalysis();
+    });
+    void runAnalysis();
+    emitter.stop = async () => {
+      await watcher?.close();
+    };
+    return emitter;
+  }
+};
+function createAnalyzer(config) {
+  return new RouteAnalyzer(config);
+}
+export {
+  IncrementalCache,
+  Invalidator,
+  Pipeline,
+  PluginRegistry,
+  RouteGraph,
+  computeGraphPatch,
+  computeMetrics,
+  createAnalyzer,
+  createSemanticFile,
+  defineConfig,
+  detectInfiniteRedirects,
+  exportDot,
+  exportHtml,
+  exportJson,
+  exportMarkdown,
+  exportMermaid,
+  exportPlantUML,
+  findCycles,
+  findDeadRoutes,
+  findShortestPath,
+  getMostConnected,
+  metricsToMetadata
+};