@launchsecure/launch-kit 0.0.4 → 0.0.5

package/dist/server/chart-serve.js

@@ -35,20 +35,41 @@ __export(chart_serve_exports, {
 });
 module.exports = __toCommonJS(chart_serve_exports);
 var import_node_http = __toESM(require("node:http"));
-var import_node_fs7 = __toESM(require("node:fs"));
-var import_node_path7 = __toESM(require("node:path"));
+var import_node_fs11 = __toESM(require("node:fs"));
+var import_node_path12 = __toESM(require("node:path"));
 
 // src/server/graph/index.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path10 = require("node:path");
 
-// src/server/graph/parsers/ui/react-nextjs.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path2 = require("node:path");
+// src/server/graph/core/graph-builder.ts
+var import_node_fs8 = require("node:fs");
+var import_node_path9 = require("node:path");
 
-// src/server/graph/core/ast-helpers.ts
+// src/server/graph/core/config.ts
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
+var CONFIG_FILENAME = ".launchchart.json";
+function loadConfig(rootDir) {
+  const configPath = (0, import_node_path.join)(rootDir, CONFIG_FILENAME);
+  if (!(0, import_node_fs.existsSync)(configPath)) return {};
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+// src/server/graph/core/parser-registry.ts
+var import_node_path8 = require("node:path");
+
+// src/server/graph/parsers/ui/react-nextjs.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/server/graph/core/ast-helpers.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
 var tsModule;
 function getTs() {
   if (!tsModule) {
@@ -59,8 +80,8 @@ function getTs() {
 var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
 function parseFile(absPath) {
   const ts = getTs();
-  const content = (0, import_node_fs.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path.extname)(absPath);
+  const content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path2.extname)(absPath);
   const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ext === ".ts" ? ts.ScriptKind.TS : ext === ".jsx" ? ts.ScriptKind.JSX : ts.ScriptKind.JS;
   const sourceFile = ts.createSourceFile(
     absPath,
@@ -338,8 +359,8 @@ var MUTATION_METHODS = /* @__PURE__ */ new Set([
 ]);
 function extractDbCalls(absPath) {
   const ts = getTs();
-  const content = (0, import_node_fs.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path.extname)(absPath);
+  const content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path2.extname)(absPath);
   const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
   const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.Latest, true, scriptKind);
   const calls = [];
@@ -368,8 +389,8 @@ function extractDbCalls(absPath) {
 }
 function extractAuthWrappers(absPath) {
   const ts = getTs();
-  const content = (0, import_node_fs.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path.extname)(absPath);
+  const content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path2.extname)(absPath);
   const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
   const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.Latest, true, scriptKind);
   const wrappers = /* @__PURE__ */ new Set();
@@ -390,12 +411,12 @@ function extractAuthWrappers(absPath) {
 var RENDER_TYPES = /* @__PURE__ */ new Set(["component", "ui", "layout", "context"]);
 function walk(dir, exts) {
   const results = [];
-  if (!(0, import_node_fs2.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
-    const full = (0, import_node_path2.join)(dir, entry.name);
+  if (!(0, import_node_fs3.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path3.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
       results.push(full);
     }
   }
@@ -403,33 +424,33 @@ function walk(dir, exts) {
 }
 function walkWithIgnore(dir, exts, ignoreDirs) {
   const results = [];
-  if (!(0, import_node_fs2.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (ignoreDirs.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path2.join)(dir, entry.name), exts, ignoreDirs));
-    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
-      results.push((0, import_node_path2.join)(dir, entry.name));
+      results.push(...walkWithIgnore((0, import_node_path3.join)(dir, entry.name), exts, ignoreDirs));
+    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
+      results.push((0, import_node_path3.join)(dir, entry.name));
     }
   }
   return results;
 }
 function toNodeId(srcDir, absPath) {
-  return (0, import_node_path2.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path3.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
 function resolveImport(srcDir, specifier) {
   if (!specifier.startsWith("@/")) return null;
   const rel = specifier.slice(2);
-  const base = (0, import_node_path2.join)(srcDir, rel);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path2.join)(base, "index.ts"), (0, import_node_path2.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs2.existsSync)(c) && (0, import_node_fs2.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path3.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path3.join)(base, "index.ts"), (0, import_node_path3.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs3.existsSync)(c) && (0, import_node_fs3.statSync)(c).isFile()) return c;
   }
   return null;
 }
 function resolveRelativeImport(fromFile, specifier) {
-  const base = (0, import_node_path2.join)((0, import_node_path2.dirname)(fromFile), specifier);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path2.join)(base, "index.ts"), (0, import_node_path2.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs2.existsSync)(c) && (0, import_node_fs2.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path3.join)((0, import_node_path3.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path3.join)(base, "index.ts"), (0, import_node_path3.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs3.existsSync)(c) && (0, import_node_fs3.statSync)(c).isFile()) return c;
   }
   return null;
 }
@@ -450,7 +471,7 @@ function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
     const resolved = resolveRelativeImport(barrelAbsPath, re.from);
     if (!resolved) continue;
     if (re.isWildcard) {
-      const targetBn = (0, import_node_path2.basename)(resolved);
+      const targetBn = (0, import_node_path3.basename)(resolved);
       const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
       if (targetIsBarrel) {
         const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
@@ -477,12 +498,12 @@ function buildAllBarrelMaps(srcDir, parsedByPath) {
   const barrels = /* @__PURE__ */ new Map();
   const memo = /* @__PURE__ */ new Map();
   for (const [absPath, parsed] of parsedByPath) {
-    const bn = (0, import_node_path2.basename)(absPath);
+    const bn = (0, import_node_path3.basename)(absPath);
     if (bn !== "index.ts" && bn !== "index.tsx") continue;
     if (parsed.reExports.length === 0) continue;
     const map = resolveBarrelMap(absPath, parsedByPath, memo, /* @__PURE__ */ new Set());
     if (map.size > 0) {
-      const barrelId = (0, import_node_path2.relative)(srcDir, (0, import_node_path2.dirname)(absPath)).replace(/\\/g, "/");
+      const barrelId = (0, import_node_path3.relative)(srcDir, (0, import_node_path3.dirname)(absPath)).replace(/\\/g, "/");
       barrels.set(barrelId, map);
     }
   }
@@ -541,7 +562,7 @@ function extractRoute(id) {
   return route || "/";
 }
 function nameFromFilename(absPath) {
-  return (0, import_node_path2.basename)(absPath, (0, import_node_path2.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+  return (0, import_node_path3.basename)(absPath, (0, import_node_path3.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
 function resolveTemplateLiteralRoute(template, routeToNodeId) {
   const parameterized = template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
@@ -622,105 +643,6 @@ function matchRouteToPage(route, routeToNodeId) {
   if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
   return null;
 }
-function loadApiRoutes(rootDir) {
-  const apiJsonPath = (0, import_node_path2.join)(rootDir, ".launchsecure", "graphs", "api.json");
-  if (!(0, import_node_fs2.existsSync)(apiJsonPath)) return [];
-  try {
-    const parsed = JSON.parse((0, import_node_fs2.readFileSync)(apiJsonPath, "utf-8"));
-    const routes = [];
-    for (const n of parsed.nodes ?? []) {
-      const path2 = n.path;
-      if (!path2 || typeof path2 !== "string") continue;
-      routes.push({
-        path: path2,
-        nodeId: n.id,
-        segments: path2.split("/").filter(Boolean)
-      });
-    }
-    return routes;
-  } catch {
-    return [];
-  }
-}
-function buildApiPathMap(routes) {
-  const map = /* @__PURE__ */ new Map();
-  for (const r of routes) {
-    if (!map.has(r.path)) map.set(r.path, r.nodeId);
-  }
-  return map;
-}
-function normalizeFetchUrl(raw) {
-  let s = raw.replace(/^`|`$/g, "");
-  const qIdx = s.indexOf("?");
-  if (qIdx >= 0) s = s.slice(0, qIdx);
-  const hIdx = s.indexOf("#");
-  if (hIdx >= 0) s = s.slice(0, hIdx);
-  let hadInterpolation = false;
-  s = s.replace(/\$\{([^}]+)\}/g, (_, expr) => {
-    hadInterpolation = true;
-    const cleaned = expr.trim();
-    const last = cleaned.split(".").pop() ?? cleaned;
-    const name = last.replace(/[^\w]/g, "") || "param";
-    return ":" + name;
-  });
-  s = s.replace(/\/+/g, "/");
-  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
-  return { path: s || "/", hadInterpolation };
-}
-function scoreApiRouteMatch(candidate, known) {
-  if (candidate.length !== known.length) return -1;
-  let score = 0;
-  for (let i = 0; i < candidate.length; i++) {
-    const a = candidate[i];
-    const b = known[i];
-    if (a === b) {
-      score += 3;
-      continue;
-    }
-    if (a.startsWith(":") && b.startsWith(":")) {
-      score += 2;
-      continue;
-    }
-    if (a.startsWith(":") || b.startsWith(":")) {
-      score += 1;
-      continue;
-    }
-    return -1;
-  }
-  return score;
-}
-function resolveFetchCall(call, apiPathMap, apiRoutes) {
-  const raw = call.url;
-  if (/^(https?:)?\/\//i.test(raw)) {
-    return { kind: "external", normalizedUrl: raw };
-  }
-  if (call.isConcat) {
-    return { kind: "dynamic", normalizedUrl: raw };
-  }
-  const { path: path2, hadInterpolation } = normalizeFetchUrl(raw);
-  if (!path2.startsWith("/")) {
-    return { kind: "unresolved", normalizedUrl: path2 };
-  }
-  const segs = path2.split("/").filter(Boolean);
-  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
-    return { kind: "dynamic", normalizedUrl: path2 };
-  }
-  const exact = apiPathMap.get(path2);
-  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path2 };
-  let bestScore = -1;
-  let bestId = null;
-  for (const r of apiRoutes) {
-    const score = scoreApiRouteMatch(segs, r.segments);
-    if (score > bestScore) {
-      bestScore = score;
-      bestId = r.nodeId;
-    }
-  }
-  if (bestId && bestScore > 0) {
-    return { kind: "resolved", nodeId: bestId, normalizedUrl: path2 };
-  }
-  return { kind: "unresolved", normalizedUrl: path2 };
-}
 function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap, barrelMaps, routeToNodeId) {
   const edges = [];
   const flagged = [];
@@ -820,26 +742,26 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap,
   return { edges, flagged };
 }
 function detect(rootDir) {
-  return (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "src", "app")) && (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "next.config.ts")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "next.config.js")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "next.config.mjs"));
+  return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "src", "app")) && (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.ts")) || (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.js")) || (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.mjs"));
 }
 function generate(rootDir) {
-  const srcDir = (0, import_node_path2.join)(rootDir, "src");
-  const appFiles = walk((0, import_node_path2.join)(srcDir, "app"), [".tsx", ".ts"]).filter(
-    (f) => (0, import_node_path2.basename)(f) !== "route.ts" && (0, import_node_path2.basename)(f) !== "route.tsx"
+  const srcDir = (0, import_node_path3.join)(rootDir, "src");
+  const appFiles = walk((0, import_node_path3.join)(srcDir, "app"), [".tsx", ".ts"]).filter(
+    (f) => (0, import_node_path3.basename)(f) !== "route.ts" && (0, import_node_path3.basename)(f) !== "route.tsx"
   );
-  const clientFiles = walk((0, import_node_path2.join)(srcDir, "client"), [".tsx", ".ts"]);
-  const serverFiles = walk((0, import_node_path2.join)(srcDir, "server"), [".ts", ".tsx"]).filter(
-    (f) => (0, import_node_path2.basename)(f) !== "route.ts" && (0, import_node_path2.basename)(f) !== "route.tsx"
+  const clientFiles = walk((0, import_node_path3.join)(srcDir, "client"), [".tsx", ".ts"]);
+  const serverFiles = walk((0, import_node_path3.join)(srcDir, "server"), [".ts", ".tsx"]).filter(
+    (f) => (0, import_node_path3.basename)(f) !== "route.ts" && (0, import_node_path3.basename)(f) !== "route.tsx"
   );
-  const libFiles = walk((0, import_node_path2.join)(srcDir, "lib"), [".ts", ".tsx"]);
-  const configFiles = walk((0, import_node_path2.join)(srcDir, "config"), [".ts", ".tsx"]);
+  const libFiles = walk((0, import_node_path3.join)(srcDir, "lib"), [".ts", ".tsx"]);
+  const configFiles = walk((0, import_node_path3.join)(srcDir, "config"), [".ts", ".tsx"]);
   const allDiscovered = [...appFiles, ...clientFiles, ...serverFiles, ...libFiles, ...configFiles];
   const parsedByPath = /* @__PURE__ */ new Map();
   for (const absPath of allDiscovered) {
     parsedByPath.set(absPath, parseFile(absPath));
   }
   const barrelMaps = buildAllBarrelMaps(srcDir, parsedByPath);
-  const fileSet = allDiscovered.filter((f) => !(0, import_node_path2.basename)(f).startsWith("index."));
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path3.basename)(f).startsWith("index."));
   const nodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const nodeTypeMap = /* @__PURE__ */ new Map();
@@ -858,7 +780,6 @@ function generate(rootDir) {
   }
   const allEdges = [];
   const allFlagged = [];
-  const crossRefs = [];
   for (const absPath of fileSet) {
     const sourceId = toNodeId(srcDir, absPath);
     const parsed = parsedByPath.get(absPath);
@@ -875,66 +796,21 @@ function generate(rootDir) {
     allEdges.push(...edges);
     allFlagged.push(...flagged);
   }
-  const apiRoutes = loadApiRoutes(rootDir);
-  const apiPathMap = buildApiPathMap(apiRoutes);
-  const includeExternalFetches = process.env.LAUNCH_CHART_INCLUDE_EXTERNAL_FETCHES === "1";
-  const fetchSeen = /* @__PURE__ */ new Set();
-  let fetchResolvedCount = 0;
-  let fetchDynamicCount = 0;
-  let fetchUnresolvedCount = 0;
-  let fetchExternalCount = 0;
+  const fetchCallEntries = [];
   for (const absPath of fileSet) {
     const sourceId = toNodeId(srcDir, absPath);
     const parsed = parsedByPath.get(absPath);
     if (parsed.fetchCalls.length === 0) continue;
-    for (const call of parsed.fetchCalls) {
-      const result = resolveFetchCall(call, apiPathMap, apiRoutes);
-      const methodTag = call.method ?? (call.kind === "fetch" ? "GET?" : "?");
-      if (result.kind === "resolved" && result.nodeId) {
-        const key = `${sourceId}\u2192${result.nodeId}\u2192calls_api`;
-        if (fetchSeen.has(key)) continue;
-        fetchSeen.add(key);
-        crossRefs.push({
-          source: sourceId,
-          target: result.nodeId,
-          type: "calls_api",
-          layer: "api"
-        });
-        fetchResolvedCount++;
-        continue;
-      }
-      if (result.kind === "dynamic") {
-        fetchDynamicCount++;
-        allFlagged.push({
-          source: sourceId,
-          target: "DYNAMIC",
-          type: "calls_api",
-          label: call.isConcat ? `${methodTag} fetch with concat: ${call.url}` : `${methodTag} fetch with template: ${call.url}`,
-          confidence: call.isConcat ? "low" : "medium"
-        });
-        continue;
-      }
-      if (result.kind === "external") {
-        fetchExternalCount++;
-        if (!includeExternalFetches) continue;
-        allFlagged.push({
-          source: sourceId,
-          target: "EXTERNAL",
-          type: "calls_external",
-          label: `${methodTag} external fetch: ${call.url}`,
-          confidence: "high"
-        });
-        continue;
-      }
-      fetchUnresolvedCount++;
-      allFlagged.push({
-        source: sourceId,
-        target: "UNRESOLVED",
-        type: "calls_api",
-        label: `${methodTag} fetch to unknown path: ${result.normalizedUrl}`,
-        confidence: "medium"
-      });
-    }
+    fetchCallEntries.push({
+      nodeId: sourceId,
+      calls: parsed.fetchCalls.map((c) => ({
+        url: c.url,
+        method: c.method,
+        isTemplate: c.isTemplate,
+        isConcat: c.isConcat,
+        kind: c.kind
+      }))
+    });
   }
   const externalScanned = new Set(allDiscovered.map((f) => f.replace(/\\/g, "/")));
   const IGNORE_DIRS = /* @__PURE__ */ new Set([
@@ -960,7 +836,7 @@ function generate(rootDir) {
     } catch {
       continue;
     }
-    const externalId = (0, import_node_path2.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const externalId = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
     const edgesFromThis = [];
     const seen = /* @__PURE__ */ new Set();
     for (const imp of parsed.imports) {
@@ -1051,20 +927,11 @@ function generate(rootDir) {
       layer: "ui",
       parser: "react-nextjs-ast",
       ...stats,
-      api_call_detection: {
-        includeExternalFetches,
-        includeConcatFetches: process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1",
-        apiRoutesLoaded: apiRoutes.length,
-        resolved: fetchResolvedCount,
-        dynamic: fetchDynamicCount,
-        unresolved: fetchUnresolvedCount,
-        external: fetchExternalCount
-      },
       notes: "Auto-generated via TypeScript AST \u2014 edges derived from actual imports, renders from JSX usage, navigations from router/Link calls."
     },
     nodes,
     edges: allEdges,
-    cross_refs: crossRefs,
+    cross_refs: [],
     contradictions: [],
     warnings: [],
     flagged_edges: dedupedFlagged,
@@ -1075,7 +942,8 @@ function generate(rootDir) {
         renders: allEdges.filter((e) => e.type === "renders").length,
         imports: allEdges.filter((e) => e.type === "imports").length,
         navigates: allEdges.filter((e) => e.type === "navigates").length
-      }
+      },
+      fetch_calls: fetchCallEntries
     }
   };
 }
@@ -1087,14 +955,14 @@ var reactNextjsParser = {
 };
 
 // src/server/graph/parsers/api/nextjs-routes.ts
-var import_node_fs3 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
 function walk2(dir) {
   const results = [];
-  if (!(0, import_node_fs3.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
-    const full = (0, import_node_path3.join)(dir, entry.name);
+  if (!(0, import_node_fs4.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path4.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk2(full));
     } else if (entry.name === "route.ts" || entry.name === "route.tsx") {
@@ -1104,7 +972,7 @@ function walk2(dir) {
   return results;
 }
 function filePathToRoute(apiDir, absPath) {
-  let route = "/" + (0, import_node_path3.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
+  let route = "/" + (0, import_node_path4.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
   route = route.replace(/\[([^\]]+)\]/g, ":$1");
   route = route.replace(/\/+/g, "/");
   if (route === "/") return "/api";
@@ -1115,10 +983,10 @@ function camelToPascal(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
 function detect2(rootDir) {
-  return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "src", "app", "api"));
+  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "src", "app", "api"));
 }
 function generate2(rootDir) {
-  const apiDir = (0, import_node_path3.join)(rootDir, "src", "app", "api");
+  const apiDir = (0, import_node_path4.join)(rootDir, "src", "app", "api");
   const routeFiles = walk2(apiDir);
   const nodes = [];
   const edges = [];
@@ -1136,7 +1004,7 @@ function generate2(rootDir) {
       if (HTTP_METHODS2.has(exp)) methods.push(exp);
     }
     const routePath = filePathToRoute(apiDir, absPath);
-    const relPath = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const relPath = (0, import_node_path4.relative)(rootDir, absPath).replace(/\\/g, "/");
     const mutations = dbCalls.filter((c) => c.isMutation);
     const reads = dbCalls.filter((c) => !c.isMutation);
     const mutates = mutations.length > 0;
@@ -1221,8 +1089,8 @@ var nextjsRoutesParser = {
 };
 
 // src/server/graph/parsers/db/prisma-schema.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
 function parseModels(content) {
   const nodes = [];
   const relations = [];
@@ -1313,11 +1181,11 @@ function parseEnums(content) {
   return nodes;
 }
 function detect3(rootDir) {
-  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "prisma", "schema.prisma"));
+  return (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "prisma", "schema.prisma"));
 }
 function generate3(rootDir) {
-  const schemaPath = (0, import_node_path4.join)(rootDir, "prisma", "schema.prisma");
-  const content = (0, import_node_fs4.readFileSync)(schemaPath, "utf-8");
+  const schemaPath = (0, import_node_path5.join)(rootDir, "prisma", "schema.prisma");
+  const content = (0, import_node_fs5.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -1373,33 +1241,651 @@ var prismaSchemaParser = {
   generate: generate3
 };
 
+// src/server/graph/core/api-route-matching.ts
+function loadApiRoutesFromOutput(apiOutput) {
+  const routes = [];
+  for (const n of apiOutput.nodes) {
+    const path2 = n.path;
+    if (!path2 || typeof path2 !== "string") continue;
+    routes.push({
+      path: path2,
+      nodeId: n.id,
+      segments: path2.split("/").filter(Boolean)
+    });
+  }
+  return routes;
+}
+function buildApiPathMap(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    if (!map.has(r.path)) map.set(r.path, r.nodeId);
+  }
+  return map;
+}
+function normalizeFetchUrl(raw) {
+  let s = raw.replace(/^`|`$/g, "");
+  const qIdx = s.indexOf("?");
+  if (qIdx >= 0) s = s.slice(0, qIdx);
+  const hIdx = s.indexOf("#");
+  if (hIdx >= 0) s = s.slice(0, hIdx);
+  let hadInterpolation = false;
+  s = s.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    hadInterpolation = true;
+    const cleaned = expr.trim();
+    const last = cleaned.split(".").pop() ?? cleaned;
+    const name = last.replace(/[^\w]/g, "") || "param";
+    return ":" + name;
+  });
+  s = s.replace(/\/+/g, "/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return { path: s || "/", hadInterpolation };
+}
+function scoreApiRouteMatch(candidate, known) {
+  if (candidate.length !== known.length) return -1;
+  let score = 0;
+  for (let i = 0; i < candidate.length; i++) {
+    const a = candidate[i];
+    const b = known[i];
+    if (a === b) {
+      score += 3;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      score += 1;
+      continue;
+    }
+    return -1;
+  }
+  return score;
+}
+function resolveFetchCall(call, apiPathMap, apiRoutes) {
+  const raw = call.url;
+  if (/^(https?:)?\/\//i.test(raw)) {
+    return { kind: "external", normalizedUrl: raw };
+  }
+  if (call.isConcat) {
+    return { kind: "dynamic", normalizedUrl: raw };
+  }
+  const { path: path2, hadInterpolation } = normalizeFetchUrl(raw);
+  if (!path2.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path2 };
+  }
+  const segs = path2.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path2 };
+  }
+  const exact = apiPathMap.get(path2);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path2 };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path2 };
+  }
+  return { kind: "unresolved", normalizedUrl: path2 };
+}
+function resolveUrlPath(urlPath, apiPathMap, apiRoutes) {
+  const { path: path2, hadInterpolation } = normalizeFetchUrl(urlPath);
+  if (!path2.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path2 };
+  }
+  const segs = path2.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path2 };
+  }
+  const exact = apiPathMap.get(path2);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path2 };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path2 };
+  }
+  return { kind: "unresolved", normalizedUrl: path2 };
+}
+
+// src/server/graph/parsers/crosslayer/fetch-resolver.ts
+var fetchResolverParser = {
+  id: "fetch-resolver",
+  layer: "crosslayer",
+  detect(_rootDir) {
+    return true;
+  },
+  generate(_rootDir, layerOutputs) {
+    const uiOutput = layerOutputs.get("ui");
+    const apiOutput = layerOutputs.get("api");
+    if (!uiOutput || !apiOutput) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+    const apiPathMap = buildApiPathMap(apiRoutes);
+    const fetchCallEntries = uiOutput.patterns?.fetch_calls ?? [];
+    if (fetchCallEntries.length === 0) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const includeExternal = process.env.LAUNCH_CHART_INCLUDE_EXTERNAL_FETCHES === "1";
+    const crossRefs = [];
+    const flaggedEdges = [];
+    const seen = /* @__PURE__ */ new Set();
+    let resolvedCount = 0;
+    let dynamicCount = 0;
+    let unresolvedCount = 0;
+    let externalCount = 0;
+    for (const entry of fetchCallEntries) {
+      for (const call of entry.calls) {
+        const result = resolveFetchCall(call, apiPathMap, apiRoutes);
+        const methodTag = call.method ?? (call.kind === "fetch" ? "GET?" : "?");
+        if (result.kind === "resolved" && result.nodeId) {
+          const key = `${entry.nodeId}\u2192${result.nodeId}\u2192calls_api`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          crossRefs.push({
+            source: entry.nodeId,
+            target: result.nodeId,
+            type: "calls_api",
+            layer: "api"
+          });
+          resolvedCount++;
+          continue;
+        }
+        if (result.kind === "dynamic") {
+          dynamicCount++;
+          flaggedEdges.push({
+            source: entry.nodeId,
+            target: "DYNAMIC",
+            type: "calls_api",
+            label: call.isConcat ? `${methodTag} fetch with concat: ${call.url}` : `${methodTag} fetch with template: ${call.url}`,
+            confidence: call.isConcat ? "low" : "medium"
+          });
+          continue;
+        }
+        if (result.kind === "external") {
+          externalCount++;
+          if (!includeExternal) continue;
+          flaggedEdges.push({
+            source: entry.nodeId,
+            target: "EXTERNAL",
+            type: "calls_external",
+            label: `${methodTag} external fetch: ${call.url}`,
+            confidence: "high"
+          });
+          continue;
+        }
+        unresolvedCount++;
+        flaggedEdges.push({
+          source: entry.nodeId,
+          target: "UNRESOLVED",
+          type: "calls_api",
+          label: `${methodTag} fetch to unknown path: ${result.normalizedUrl}`,
+          confidence: "medium"
+        });
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: flaggedEdges,
+      warnings: [],
+      patterns: {
+        api_call_detection: {
+          resolved: resolvedCount,
+          dynamic: dynamicCount,
+          unresolved: unresolvedCount,
+          external: externalCount
+        }
+      }
+    };
+  }
+};
+
+// src/server/graph/parsers/crosslayer/api-annotations.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
+var API_ANNOTATION_RE = /@api\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S+)/g;
+function walk3(dir, exts) {
+  if (!(0, import_node_fs6.existsSync)(dir)) return [];
+  const results = [];
+  for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const full = (0, import_node_path6.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk3(full, exts));
+    } else if (exts.includes((0, import_node_path6.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function toNodeId2(srcDir, absPath) {
+  return (0, import_node_path6.relative)(srcDir, absPath).replace(/\\/g, "/");
+}
+var apiAnnotationsParser = {
+  id: "api-annotations",
+  layer: "crosslayer",
+  detect(rootDir) {
+    return (0, import_node_fs6.existsSync)((0, import_node_path6.join)(rootDir, "src"));
+  },
+  generate(rootDir, layerOutputs) {
+    const apiOutput = layerOutputs.get("api");
+    if (!apiOutput) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const uiOutput = layerOutputs.get("ui");
+    const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
+    const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+    const apiPathMap = buildApiPathMap(apiRoutes);
+    const srcDir = (0, import_node_path6.join)(rootDir, "src");
+    const files = walk3(srcDir, [".ts", ".tsx"]);
+    const crossRefs = [];
+    const flaggedEdges = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const absPath of files) {
+      const content = (0, import_node_fs6.readFileSync)(absPath, "utf-8");
+      const sourceId = toNodeId2(srcDir, absPath);
+      if (!uiNodeIds.has(sourceId)) continue;
+      let match;
+      API_ANNOTATION_RE.lastIndex = 0;
+      while ((match = API_ANNOTATION_RE.exec(content)) !== null) {
+        const method = match[1];
+        const urlPath = match[2];
+        const result = resolveUrlPath(urlPath, apiPathMap, apiRoutes);
+        if (result.kind === "resolved" && result.nodeId) {
+          const key = `${sourceId}|${result.nodeId}|calls_api`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          crossRefs.push({
+            source: sourceId,
+            target: result.nodeId,
+            type: "calls_api",
+            layer: "api"
+          });
+        } else {
+          flaggedEdges.push({
+            source: sourceId,
+            target: "UNRESOLVED",
+            type: "annotation_unresolved",
+            label: `@api ${method} ${urlPath} \u2014 no matching API route found`,
+            confidence: "high"
+          });
+        }
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: flaggedEdges,
+      warnings: [],
+      patterns: {
+        annotations_found: crossRefs.length + flaggedEdges.length,
+        annotations_resolved: crossRefs.length,
+        annotations_unresolved: flaggedEdges.length
+      }
+    };
+  }
+};
+
+// src/server/graph/parsers/crosslayer/url-literal-scanner.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path7 = require("node:path");
+var URL_LITERAL_RE = /['"`](\/api\/[^'"`\s]+?)['"`]/g;
+function walk4(dir, exts) {
+  if (!(0, import_node_fs7.existsSync)(dir)) return [];
+  const results = [];
+  for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const full = (0, import_node_path7.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk4(full, exts));
+    } else if (exts.includes((0, import_node_path7.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function toNodeId3(srcDir, absPath) {
+  return (0, import_node_path7.relative)(srcDir, absPath).replace(/\\/g, "/");
+}
+var urlLiteralScannerParser = {
+  id: "url-literal-scanner",
+  layer: "crosslayer",
+  detect(rootDir) {
+    return (0, import_node_fs7.existsSync)((0, import_node_path7.join)(rootDir, "src"));
+  },
+  generate(rootDir, layerOutputs) {
+    const apiOutput = layerOutputs.get("api");
+    if (!apiOutput) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const uiOutput = layerOutputs.get("ui");
+    const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
+    const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+    const apiPathMap = buildApiPathMap(apiRoutes);
+    const srcDir = (0, import_node_path7.join)(rootDir, "src");
+    const clientDir = (0, import_node_path7.join)(srcDir, "client");
+    const appDir = (0, import_node_path7.join)(srcDir, "app");
+    const files = [
+      ...walk4(clientDir, [".ts", ".tsx"]),
+      ...walk4(appDir, [".ts", ".tsx"])
+    ];
+    const crossRefs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const absPath of files) {
+      const sourceId = toNodeId3(srcDir, absPath);
+      if (!uiNodeIds.has(sourceId)) continue;
+      const content = (0, import_node_fs7.readFileSync)(absPath, "utf-8");
+      let match;
+      URL_LITERAL_RE.lastIndex = 0;
+      while ((match = URL_LITERAL_RE.exec(content)) !== null) {
+        const urlPath = match[1];
+        const result = resolveUrlPath(urlPath, apiPathMap, apiRoutes);
+        if (result.kind === "resolved" && result.nodeId) {
+          const key = `${sourceId}|${result.nodeId}|references_api`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          crossRefs.push({
+            source: sourceId,
+            target: result.nodeId,
+            type: "references_api",
+            layer: "api"
+          });
+        }
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: [],
+      warnings: [],
+      patterns: {
+        url_literals_resolved: crossRefs.length
+      }
+    };
+  }
+};
+
+// src/server/graph/core/parser-registry.ts
+var ParserRegistry = class {
+  constructor() {
+    this.parsers = /* @__PURE__ */ new Map();
+    this.ids = /* @__PURE__ */ new Set();
+  }
+  register(parser) {
+    if (this.ids.has(parser.id)) {
+      throw new Error(`Duplicate parser id: ${parser.id}`);
+    }
+    this.ids.add(parser.id);
+    const list = this.parsers.get(parser.layer) ?? [];
+    list.push(parser);
+    this.parsers.set(parser.layer, list);
+  }
+  getParsers(layer) {
+    return this.parsers.get(layer) ?? [];
+  }
+  getCrossLayerParsers() {
+    return this.parsers.get("crosslayer") ?? [];
+  }
+  getAll() {
+    const all = [];
+    for (const list of this.parsers.values()) all.push(...list);
+    return all;
+  }
+};
+function registerBuiltins(registry, disabled) {
+  const builtins = [
+    reactNextjsParser,
+    nextjsRoutesParser,
+    prismaSchemaParser,
+    fetchResolverParser,
+    apiAnnotationsParser,
+    urlLiteralScannerParser
+  ];
+  for (const parser of builtins) {
+    if (disabled.has(parser.id)) continue;
+    registry.register(parser);
+  }
+}
+function loadCustomParsers(registry, config, rootDir, disabled) {
+  for (const entry of config.parsers?.custom ?? []) {
+    try {
+      const absPath = (0, import_node_path8.resolve)(rootDir, entry.path);
+      const mod = require(absPath);
+      const parser = "default" in mod ? mod.default : mod;
+      if (disabled.has(parser.id)) continue;
+      if (parser.layer !== entry.layer) {
+        process.stderr.write(
+          `[launch-chart] custom parser "${parser.id}" declares layer "${parser.layer}" but config says "${entry.layer}" \u2014 using parser's layer
+`
+        );
+      }
+      registry.register(parser);
+    } catch (err) {
+      process.stderr.write(`[launch-chart] failed to load custom parser from ${entry.path}: ${err}
+`);
+    }
+  }
+}
+function createRegistry(config, rootDir) {
+  const registry = new ParserRegistry();
+  const disabled = new Set(config.parsers?.disabled ?? []);
+  registerBuiltins(registry, disabled);
+  loadCustomParsers(registry, config, rootDir, disabled);
+  return registry;
+}
+
+// src/server/graph/core/merge.ts
+function mergeGraphOutputs(outputs, layer) {
+  if (outputs.length === 0) {
+    return {
+      metadata: { generated: (/* @__PURE__ */ new Date()).toISOString(), scope: "", layer },
+      nodes: [],
+      edges: [],
+      cross_refs: [],
+      contradictions: [],
+      warnings: [],
+      flagged_edges: []
+    };
+  }
+  if (outputs.length === 1) return outputs[0];
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const seenCrossRefs = /* @__PURE__ */ new Set();
+  const mergedNodes = [];
+  const mergedEdges = [];
+  const mergedCrossRefs = [];
+  const mergedContradictions = [];
+  const mergedWarnings = [];
+  const mergedFlagged = [];
+  const parserIds = [];
+  for (const output of outputs) {
+    if (output.metadata.parser) {
+      parserIds.push(String(output.metadata.parser));
+    }
+    for (const node of output.nodes) {
+      if (seenNodes.has(node.id)) {
+        mergedWarnings.push({
+          type: "merge_conflict",
+          detail: `Node "${node.id}" produced by multiple parsers; keeping first`
+        });
+        continue;
+      }
+      seenNodes.add(node.id);
+      mergedNodes.push(node);
+    }
+    for (const edge of output.edges) {
+      const key = `${edge.source}|${edge.target}|${edge.type}`;
+      if (seenEdges.has(key)) continue;
+      seenEdges.add(key);
+      mergedEdges.push(edge);
+    }
+    for (const ref of output.cross_refs) {
+      const key = `${ref.source}|${ref.target}|${ref.type}`;
+      if (seenCrossRefs.has(key)) continue;
+      seenCrossRefs.add(key);
+      mergedCrossRefs.push(ref);
+    }
+    mergedContradictions.push(...output.contradictions);
+    mergedWarnings.push(...output.warnings);
+    mergedFlagged.push(...output.flagged_edges);
+  }
+  const metadata = {
+    ...outputs[0].metadata,
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    parsers: parserIds
+  };
+  return {
+    metadata,
+    nodes: mergedNodes,
+    edges: mergedEdges,
+    cross_refs: mergedCrossRefs,
+    contradictions: mergedContradictions,
+    warnings: mergedWarnings,
+    flagged_edges: mergedFlagged,
+    patterns: outputs[0].patterns
+  };
+}
+function dedupCrossRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ref of refs) {
+    const key = `${ref.source}|${ref.target}|${ref.type}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(ref);
+  }
+  return result;
+}
+function applyCrossLayerResults(uiOutput, results, primaryId) {
+  const allCrossRefs = [...uiOutput.cross_refs];
+  const allFlagged = [...uiOutput.flagged_edges];
+  const allWarnings = [...uiOutput.warnings];
+  const primaryResult = results.find((r) => r.parserId === primaryId);
+  const secondaryResults = results.filter((r) => r.parserId !== primaryId);
+  if (primaryResult) {
+    allCrossRefs.push(...primaryResult.output.cross_refs);
+    allFlagged.push(...primaryResult.output.flagged_edges);
+    allWarnings.push(...primaryResult.output.warnings);
+  }
+  const primarySet = new Set(
+    (primaryResult?.output.cross_refs ?? []).map((r) => `${r.source}|${r.target}|${r.type}`)
+  );
+  for (const sec of secondaryResults) {
+    for (const ref of sec.output.cross_refs) {
+      const key = `${ref.source}|${ref.target}|${ref.type}`;
+      if (primarySet.has(key)) {
+        allCrossRefs.push(ref);
+      } else {
+        allFlagged.push({
+          source: ref.source,
+          target: ref.target,
+          type: "out_of_pattern",
+          label: `API call detected by ${sec.parserId} but not by primary (${primaryId})`,
+          confidence: "medium"
+        });
+        allCrossRefs.push(ref);
+      }
+    }
+    allFlagged.push(...sec.output.flagged_edges);
+    allWarnings.push(...sec.output.warnings);
+  }
+  return {
+    ...uiOutput,
+    cross_refs: dedupCrossRefs(allCrossRefs),
+    flagged_edges: allFlagged,
+    warnings: allWarnings
+  };
+}
+
 // src/server/graph/core/graph-builder.ts
-var ALL_PARSERS = [
-  reactNextjsParser,
-  nextjsRoutesParser,
-  prismaSchemaParser
-];
-function getParser(layer) {
-  return ALL_PARSERS.find((p) => p.layer === layer);
+function readGraphFromDisk(rootDir, layer) {
+  const filePath = (0, import_node_path9.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
+  if (!(0, import_node_fs8.existsSync)(filePath)) return null;
+  try {
+    return JSON.parse((0, import_node_fs8.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
 }
 function generateLayer(rootDir, layer) {
-  const parser = getParser(layer);
-  if (!parser) return null;
-  if (!parser.detect(rootDir)) return null;
-  const output = parser.generate(rootDir);
+  const config = loadConfig(rootDir);
+  const registry = createRegistry(config, rootDir);
+  const parsers = registry.getParsers(layer);
+  const outputs = [];
+  for (const parser of parsers) {
+    if (!parser.detect(rootDir)) continue;
+    outputs.push(parser.generate(rootDir));
+  }
+  if (outputs.length === 0) return null;
+  let merged = outputs.length === 1 ? outputs[0] : mergeGraphOutputs(outputs, layer);
+  if (layer === "ui") {
+    const layerOutputs = /* @__PURE__ */ new Map();
+    layerOutputs.set("ui", merged);
+    for (const otherLayer of ["api", "db"]) {
+      const existing = readGraphFromDisk(rootDir, otherLayer);
+      if (existing) layerOutputs.set(otherLayer, existing);
+    }
+    const crossParsers = registry.getCrossLayerParsers();
+    const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
+    const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
+    if (crossResults.length > 0) {
+      merged = applyCrossLayerResults(merged, crossResults, primaryId);
+    }
+  }
   return {
     layer,
-    output,
-    nodeCount: output.nodes.length,
-    edgeCount: output.edges.length
+    output: merged,
+    nodeCount: merged.nodes.length,
+    edgeCount: merged.edges.length
   };
 }
 function generateAll(rootDir) {
-  const layers = ["api", "db", "ui"];
+  const config = loadConfig(rootDir);
+  const registry = createRegistry(config, rootDir);
+  const layerOrder = ["api", "db", "ui"];
+  const layerOutputs = /* @__PURE__ */ new Map();
   const results = [];
-  for (const layer of layers) {
-    const result = generateLayer(rootDir, layer);
-    if (result) results.push(result);
+  for (const layer of layerOrder) {
+    const parsers = registry.getParsers(layer);
+    const outputs = [];
+    for (const parser of parsers) {
+      if (!parser.detect(rootDir)) continue;
+      outputs.push(parser.generate(rootDir));
+    }
+    if (outputs.length === 0) continue;
+    const merged = outputs.length === 1 ? outputs[0] : mergeGraphOutputs(outputs, layer);
+    layerOutputs.set(layer, merged);
+    results.push({
+      layer,
+      output: merged,
+      nodeCount: merged.nodes.length,
+      edgeCount: merged.edges.length
+    });
+  }
+  const crossParsers = registry.getCrossLayerParsers();
+  const primaryId = config.parsers?.primary?.crosslayer ?? crossParsers[0]?.id ?? null;
+  const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
+  if (crossResults.length > 0 && layerOutputs.has("ui")) {
+    const uiOutput = layerOutputs.get("ui");
+    const merged = applyCrossLayerResults(uiOutput, crossResults, primaryId);
+    layerOutputs.set("ui", merged);
+    const uiResult = results.find((r) => r.layer === "ui");
+    if (uiResult) {
+      uiResult.output = merged;
+      uiResult.nodeCount = merged.nodes.length;
+      uiResult.edgeCount = merged.edges.length;
+    }
   }
   const byLayer = new Map(results.map((r) => [r.layer, r]));
   return ["ui", "api", "db"].map((l) => byLayer.get(l)).filter((r) => !!r);
@@ -1410,23 +1896,23 @@ var GRAPHS_DIR = ".launchsecure/graphs";
 var LAYERS = ["ui", "api", "db"];
 var graphCache = /* @__PURE__ */ new Map();
 function graphsDir(rootDir) {
-  return (0, import_node_path5.join)(rootDir, GRAPHS_DIR);
+  return (0, import_node_path10.join)(rootDir, GRAPHS_DIR);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path5.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path10.join)(graphsDir(rootDir), `${layer}.json`);
 }
 function invalidateCache(filePath) {
   graphCache.delete(filePath);
 }
 function readGraph(rootDir, layer) {
   const filePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs5.existsSync)(filePath)) return null;
-  const stat = (0, import_node_fs5.statSync)(filePath);
+  if (!(0, import_node_fs9.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs9.statSync)(filePath);
   const cached = graphCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.graph;
   }
-  const content = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs9.readFileSync)(filePath, "utf-8");
   const graph = JSON.parse(content);
   graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
   return graph;
@@ -1441,11 +1927,11 @@ function readAllGraphs(rootDir) {
 }
 function generateGraph(rootDir, layer) {
   const dir = graphsDir(rootDir);
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
   const results = layer ? [generateLayer(rootDir, layer)].filter((r) => r !== null) : generateAll(rootDir);
   for (const result of results) {
     const filePath = graphFilePath(rootDir, result.layer);
-    (0, import_node_fs5.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
+    (0, import_node_fs9.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
     invalidateCache(filePath);
   }
   return results;
@@ -1453,20 +1939,20 @@ function generateGraph(rootDir, layer) {
 
 // src/server/lockfile.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs6 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_node_os = require("node:os");
-var import_node_path6 = require("node:path");
+var import_node_path11 = require("node:path");
 function lockDir() {
-  return (0, import_node_path6.join)((0, import_node_os.homedir)(), ".launchsecure");
+  return (0, import_node_path11.join)((0, import_node_os.homedir)(), ".launchsecure");
 }
 function lockPath() {
-  return (0, import_node_path6.join)(lockDir(), "launch-chart.lock");
+  return (0, import_node_path11.join)(lockDir(), "launch-chart.lock");
 }
 function readLock() {
   const p = lockPath();
-  if (!(0, import_node_fs6.existsSync)(p)) return null;
+  if (!(0, import_node_fs10.existsSync)(p)) return null;
   try {
-    const data = JSON.parse((0, import_node_fs6.readFileSync)(p, "utf-8"));
+    const data = JSON.parse((0, import_node_fs10.readFileSync)(p, "utf-8"));
     if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
     return data;
   } catch {
@@ -1502,7 +1988,7 @@ function getLiveLock() {
   const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
   if (!live) {
     try {
-      (0, import_node_fs6.unlinkSync)(lockPath());
+      (0, import_node_fs10.unlinkSync)(lockPath());
     } catch {
     }
     return null;
@@ -1510,12 +1996,12 @@ function getLiveLock() {
   return lock;
 }
 function writeLock(data) {
-  (0, import_node_fs6.mkdirSync)(lockDir(), { recursive: true });
-  (0, import_node_fs6.writeFileSync)(lockPath(), JSON.stringify(data, null, 2) + "\n", "utf-8");
+  (0, import_node_fs10.mkdirSync)(lockDir(), { recursive: true });
+  (0, import_node_fs10.writeFileSync)(lockPath(), JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 function clearLock() {
   try {
-    (0, import_node_fs6.unlinkSync)(lockPath());
+    (0, import_node_fs10.unlinkSync)(lockPath());
   } catch {
   }
 }
@@ -1537,16 +2023,16 @@ var MIME_TYPES = {
 function findProjectRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
-    const graphsDir2 = import_node_path7.default.join(dir, ".launchsecure", "graphs");
-    if (import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "ui.json")) || import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "api.json")) || import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "db.json"))) return dir;
-    const parent = import_node_path7.default.dirname(dir);
+    const graphsDir2 = import_node_path12.default.join(dir, ".launchsecure", "graphs");
+    if (import_node_fs11.default.existsSync(import_node_path12.default.join(graphsDir2, "ui.json")) || import_node_fs11.default.existsSync(import_node_path12.default.join(graphsDir2, "api.json")) || import_node_fs11.default.existsSync(import_node_path12.default.join(graphsDir2, "db.json"))) return dir;
+    const parent = import_node_path12.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = startDir;
   for (let i = 0; i < 8; i++) {
-    if (import_node_fs7.default.existsSync(import_node_path7.default.join(dir, ".git"))) return dir;
-    const parent = import_node_path7.default.dirname(dir);
+    if (import_node_fs11.default.existsSync(import_node_path12.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path12.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1598,16 +2084,16 @@ function buildMergedGraph(projectRoot) {
   };
 }
 function serveStatic(res, filePath) {
-  if (!import_node_fs7.default.existsSync(filePath) || !import_node_fs7.default.statSync(filePath).isFile()) return false;
-  const ext = import_node_path7.default.extname(filePath).toLowerCase();
+  if (!import_node_fs11.default.existsSync(filePath) || !import_node_fs11.default.statSync(filePath).isFile()) return false;
+  const ext = import_node_path12.default.extname(filePath).toLowerCase();
   const mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
-  import_node_fs7.default.createReadStream(filePath).pipe(res);
+  import_node_fs11.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function serveIndex(res, clientDir) {
-  const indexPath = import_node_path7.default.join(clientDir, "index.html");
-  if (!import_node_fs7.default.existsSync(indexPath)) {
+  const indexPath = import_node_path12.default.join(clientDir, "index.html");
+  if (!import_node_fs11.default.existsSync(indexPath)) {
     res.writeHead(500, { "Content-Type": "text/plain" });
     res.end(`LaunchChart client bundle not found at ${clientDir}. Run 'npm run build:chart-client'.`);
     return;
@@ -1615,14 +2101,14 @@ function serveIndex(res, clientDir) {
   serveStatic(res, indexPath);
 }
 function tryListen(server, port) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve(port);
+      resolve2(port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -1659,7 +2145,7 @@ async function startChartServer(opts = {}) {
     }
     return { port: existing.port, url: existing.url };
   }
-  const clientDir = opts.clientDir ?? import_node_path7.default.join(__dirname, "..", "chart-client");
+  const clientDir = opts.clientDir ?? import_node_path12.default.join(__dirname, "..", "chart-client");
   const server = import_node_http.default.createServer((req, res) => {
     try {
       const url2 = new URL(req.url ?? "/", `http://${req.headers.host}`);
@@ -1702,8 +2188,43 @@ async function startChartServer(opts = {}) {
         res.end(JSON.stringify({ ok: true, projectRoot }));
         return;
       }
+      if (req.method === "GET" && url2.pathname === "/api/parser-config") {
+        const config = loadConfig(projectRoot);
+        const detection = [
+          { id: "react-nextjs", layer: "ui", label: "React + Next.js", detected: reactNextjsParser.detect(projectRoot) },
+          { id: "nextjs-routes", layer: "api", label: "Next.js API Routes", detected: nextjsRoutesParser.detect(projectRoot) },
+          { id: "prisma-schema", layer: "db", label: "Prisma Schema", detected: prismaSchemaParser.detect(projectRoot) }
+        ];
+        const crosslayerParsers = [
+          { id: "fetch-resolver", label: "Fetch / api.method() calls" },
+          { id: "api-annotations", label: "@api annotations" },
+          { id: "url-literal-scanner", label: "/api/... URL literals" }
+        ];
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ config, detection, crosslayerParsers }));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/parser-config") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const newConfig = JSON.parse(body);
+            const configPath = import_node_path12.default.join(projectRoot, ".launchchart.json");
+            import_node_fs11.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err) }));
+          }
+        });
+        return;
+      }
       if (url2.pathname !== "/") {
-        const staticPath = import_node_path7.default.join(clientDir, url2.pathname);
+        const staticPath = import_node_path12.default.join(clientDir, url2.pathname);
         if (serveStatic(res, staticPath)) return;
       }
       serveIndex(res, clientDir);