@launchsecure/launch-kit 0.0.3 → 0.0.5

package/dist/server/chart-serve.js

@@ -0,0 +1,2285 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/chart-serve.ts
+var chart_serve_exports = {};
+__export(chart_serve_exports, {
+  runServeCli: () => runServeCli,
+  startChartServer: () => startChartServer
+});
+module.exports = __toCommonJS(chart_serve_exports);
+var import_node_http = __toESM(require("node:http"));
+var import_node_fs11 = __toESM(require("node:fs"));
+var import_node_path12 = __toESM(require("node:path"));
+
+// src/server/graph/index.ts
+var import_node_fs9 = require("node:fs");
+var import_node_path10 = 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/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) {
+    tsModule = require("typescript");
+  }
+  return tsModule;
+}
+var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
+function parseFile(absPath) {
+  const ts = getTs();
+  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,
+    content,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    scriptKind
+  );
+  const exportsSet = /* @__PURE__ */ new Set();
+  const exportsOrdered = [];
+  let defaultName = null;
+  let firstValueExport = null;
+  let firstTypeExport = null;
+  const imports = [];
+  const reExports = [];
+  const jsxElements = /* @__PURE__ */ new Set();
+  const navigations = [];
+  const fetchCalls = [];
+  const includeConcat = process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1";
+  function addExport(name2, kind) {
+    if (!exportsSet.has(name2)) {
+      exportsSet.add(name2);
+      exportsOrdered.push(name2);
+    }
+    if (kind === "default") defaultName = name2;
+    else if (kind === "value" && !firstValueExport) firstValueExport = name2;
+    else if (kind === "type" && !firstTypeExport) firstTypeExport = name2;
+  }
+  function hasModifier(node, kind) {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+    return modifiers?.some((m) => m.kind === kind) ?? false;
+  }
+  function extractTargetFromExpression(expr) {
+    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+      return { target: expr.text, isTemplate: false };
+    }
+    if (ts.isTemplateExpression(expr)) {
+      return { target: expr.getText(sourceFile), isTemplate: true };
+    }
+    return null;
+  }
+  function looksLikeUrl(s) {
+    return s.startsWith("/") || /^(https?:)?\/\//i.test(s);
+  }
+  function templateStartsWithSlash(expr) {
+    const head = expr.head.text;
+    return head.startsWith("/");
+  }
+  function extractUrlFromFetchArg(arg) {
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+      if (!looksLikeUrl(arg.text)) return null;
+      return { url: arg.text, isTemplate: false };
+    }
+    if (ts.isTemplateExpression(arg)) {
+      if (!templateStartsWithSlash(arg)) return null;
+      return { url: arg.getText(sourceFile), isTemplate: true };
+    }
+    if (includeConcat && ts.isBinaryExpression(arg) && arg.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      let leftmost = arg;
+      while (ts.isBinaryExpression(leftmost) && leftmost.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+        leftmost = leftmost.left;
+      }
+      if ((ts.isStringLiteral(leftmost) || ts.isNoSubstitutionTemplateLiteral(leftmost)) && leftmost.text.startsWith("/")) {
+        return { url: arg.getText(sourceFile), isTemplate: false, isConcat: true };
+      }
+    }
+    return null;
+  }
+  function visit(node) {
+    if (ts.isImportDeclaration(node)) {
+      const moduleSpec = node.moduleSpecifier;
+      if (ts.isStringLiteral(moduleSpec)) {
+        const specifier = moduleSpec.text;
+        const clause = node.importClause;
+        const isTypeOnly = !!clause?.isTypeOnly;
+        const names = [];
+        const typeNames = /* @__PURE__ */ new Set();
+        if (clause) {
+          if (clause.name) names.push(clause.name.text);
+          const nb = clause.namedBindings;
+          if (nb && ts.isNamedImports(nb)) {
+            for (const el of nb.elements) {
+              names.push(el.name.text);
+              if (el.isTypeOnly) typeNames.add(el.name.text);
+            }
+          } else if (nb && ts.isNamespaceImport(nb)) {
+            names.push(nb.name.text);
+          }
+        }
+        if (names.length > 0 || isTypeOnly) {
+          imports.push({ names, specifier, isTypeOnly, typeNames });
+        } else if (!clause) {
+          imports.push({ names: [], specifier, isTypeOnly: false, typeNames: /* @__PURE__ */ new Set() });
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node)) {
+      const fromSpec = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
+      if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+        for (const el of node.exportClause.elements) {
+          const exportedName = el.name.text;
+          addExport(exportedName, "value");
+          if (fromSpec) {
+            reExports.push({ name: exportedName, from: fromSpec });
+          }
+        }
+      } else if (!node.exportClause && fromSpec) {
+        reExports.push({ name: "*", from: fromSpec, isWildcard: true });
+      }
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const arg = node.arguments[0];
+      if (arg && ts.isStringLiteral(arg)) {
+        imports.push({
+          names: [],
+          specifier: arg.text,
+          isTypeOnly: false,
+          typeNames: /* @__PURE__ */ new Set()
+        });
+      }
+    }
+    if (ts.isExportAssignment(node) && !node.isExportEquals) {
+      if (ts.isIdentifier(node.expression)) {
+        addExport(node.expression.text, "default");
+      } else {
+        if (!defaultName) defaultName = "default";
+      }
+    }
+    if (ts.isFunctionDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      const isDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
+      if (node.name) addExport(node.name.text, isDefault ? "default" : "value");
+    }
+    if (ts.isVariableStatement(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name)) {
+          addExport(decl.name.text, "value");
+        }
+      }
+    }
+    if (ts.isClassDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      const isDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
+      if (node.name) addExport(node.name.text, isDefault ? "default" : "value");
+    }
+    if (ts.isTypeAliasDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      addExport(node.name.text, "type");
+    }
+    if (ts.isInterfaceDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      addExport(node.name.text, "type");
+    }
+    if (ts.isEnumDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      addExport(node.name.text, "value");
+    }
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const tagName = node.tagName;
+      if (ts.isIdentifier(tagName) && /^[A-Z]/.test(tagName.text)) {
+        jsxElements.add(tagName.text);
+      } else if (ts.isPropertyAccessExpression(tagName)) {
+        let root = tagName;
+        while (ts.isPropertyAccessExpression(root)) root = root.expression;
+        if (ts.isIdentifier(root) && /^[A-Z]/.test(root.text)) {
+          jsxElements.add(root.text);
+        }
+      }
+    }
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "router" && (expr.name.text === "push" || expr.name.text === "replace")) {
+        const arg = node.arguments[0];
+        if (arg) {
+          const parsed = extractTargetFromExpression(arg);
+          if (parsed) {
+            navigations.push({
+              kind: expr.name.text === "push" ? "router-push" : "router-replace",
+              target: parsed.target,
+              isTemplate: parsed.isTemplate
+            });
+          }
+        }
+      }
+    }
+    if (ts.isCallExpression(node) && node.arguments.length > 0) {
+      const expr = node.expression;
+      const firstArg = node.arguments[0];
+      if (ts.isIdentifier(expr) && expr.text === "fetch") {
+        const extracted = extractUrlFromFetchArg(firstArg);
+        if (extracted) {
+          fetchCalls.push({
+            url: extracted.url,
+            isTemplate: extracted.isTemplate,
+            ...extracted.isConcat ? { isConcat: true } : {},
+            kind: "fetch"
+          });
+        }
+      }
+      if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.name)) {
+        const methodName = expr.name.text;
+        if (HTTP_METHODS.has(methodName)) {
+          const extracted = extractUrlFromFetchArg(firstArg);
+          if (extracted) {
+            fetchCalls.push({
+              method: methodName.toUpperCase(),
+              url: extracted.url,
+              isTemplate: extracted.isTemplate,
+              ...extracted.isConcat ? { isConcat: true } : {},
+              kind: "client-method"
+            });
+          }
+        }
+      }
+    }
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const tagName = node.tagName;
+      if (ts.isIdentifier(tagName) && tagName.text === "Link") {
+        for (const attr of node.attributes.properties) {
+          if (ts.isJsxAttribute(attr) && attr.name.getText(sourceFile) === "href" && attr.initializer) {
+            const init = attr.initializer;
+            if (ts.isStringLiteral(init)) {
+              navigations.push({ kind: "link-href", target: init.text, isTemplate: false });
+            } else if (ts.isJsxExpression(init) && init.expression) {
+              const parsed = extractTargetFromExpression(init.expression);
+              if (parsed) {
+                navigations.push({ kind: "link-href", target: parsed.target, isTemplate: parsed.isTemplate });
+              }
+            }
+          }
+        }
+      }
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const left = node.left;
+      if (ts.isPropertyAccessExpression(left) && ts.isPropertyAccessExpression(left.expression) && ts.isIdentifier(left.expression.expression) && left.expression.expression.text === "window" && left.expression.name.text === "location" && left.name.text === "href") {
+        const parsed = extractTargetFromExpression(node.right);
+        if (parsed) {
+          navigations.push({ kind: "window-location", target: parsed.target, isTemplate: parsed.isTemplate });
+        }
+      }
+    }
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isPropertyAccessExpression(expr) && ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.expression) && expr.expression.expression.text === "window" && expr.expression.name.text === "location" && (expr.name.text === "assign" || expr.name.text === "replace")) {
+        const arg = node.arguments[0];
+        if (arg) {
+          const parsed = extractTargetFromExpression(arg);
+          if (parsed) {
+            navigations.push({ kind: "window-location", target: parsed.target, isTemplate: parsed.isTemplate });
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
+  return {
+    name,
+    exports: exportsOrdered,
+    imports,
+    reExports,
+    jsxElements,
+    navigations,
+    fetchCalls
+  };
+}
+var MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert",
+  "delete",
+  "deleteMany"
+]);
+function extractDbCalls(absPath) {
+  const ts = getTs();
+  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 = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isPropertyAccessExpression(expr) && ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.expression) && expr.expression.expression.text === "db") {
+        const model = expr.expression.name.text;
+        const method = expr.name.text;
+        const key = `${model}.${method}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          calls.push({
+            model,
+            method,
+            isMutation: MUTATION_METHODS.has(method)
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return calls;
+}
+function extractAuthWrappers(absPath) {
+  const ts = getTs();
+  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();
+  const AUTH_WRAPPERS = /* @__PURE__ */ new Set(["withAuth", "withPermission", "withRole", "requireAuth"]);
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      if (AUTH_WRAPPERS.has(node.expression.text)) {
+        wrappers.add(node.expression.text);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return wrappers;
+}
+
+// src/server/graph/parsers/ui/react-nextjs.ts
+var RENDER_TYPES = /* @__PURE__ */ new Set(["component", "ui", "layout", "context"]);
+function walk(dir, exts) {
+  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 (entry.isDirectory()) {
+      results.push(...walk(full, exts));
+    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function walkWithIgnore(dir, exts, ignoreDirs) {
+  const results = [];
+  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_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_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_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_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;
+}
+function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
+  const cached = memo.get(barrelAbsPath);
+  if (cached) return cached;
+  if (visiting.has(barrelAbsPath)) return /* @__PURE__ */ new Map();
+  visiting.add(barrelAbsPath);
+  const parsed = parsedByPath.get(barrelAbsPath);
+  const map = /* @__PURE__ */ new Map();
+  if (!parsed) {
+    visiting.delete(barrelAbsPath);
+    memo.set(barrelAbsPath, map);
+    return map;
+  }
+  for (const re of parsed.reExports) {
+    if (!re.from.startsWith(".")) continue;
+    const resolved = resolveRelativeImport(barrelAbsPath, re.from);
+    if (!resolved) continue;
+    if (re.isWildcard) {
+      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);
+        for (const [name, target] of nested) {
+          if (!map.has(name)) map.set(name, target);
+        }
+      } else {
+        const targetParsed = parsedByPath.get(resolved);
+        if (targetParsed) {
+          for (const exp of targetParsed.exports) {
+            if (!map.has(exp)) map.set(exp, resolved);
+          }
+        }
+      }
+    } else {
+      if (!map.has(re.name)) map.set(re.name, resolved);
+    }
+  }
+  visiting.delete(barrelAbsPath);
+  memo.set(barrelAbsPath, map);
+  return map;
+}
+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_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_path3.relative)(srcDir, (0, import_node_path3.dirname)(absPath)).replace(/\\/g, "/");
+      barrels.set(barrelId, map);
+    }
+  }
+  return barrels;
+}
+function classifyType(id) {
+  if (id.endsWith("/page.tsx")) return "page";
+  if (id.endsWith("/layout.tsx")) return "layout";
+  if (id.startsWith("client/components/ui/")) return "ui";
+  if (id.startsWith("client/components/")) return "component";
+  if (id.startsWith("client/hooks/")) return "hook";
+  if (/client\/lib\/.*-context\./.test(id)) return "context";
+  if (id.startsWith("client/lib/")) return id.includes("config") ? "config" : "util";
+  if (id.startsWith("client/api/")) return "util";
+  if (id.startsWith("server/mcp/")) return "mcp-tool";
+  if (id.startsWith("server/lib/")) return "lib";
+  if (id.startsWith("server/")) return "lib";
+  if (id.startsWith("lib/") || id.startsWith("config/")) return "lib";
+  return "component";
+}
+function classifyModule(id) {
+  if (/app\/\(auth\)\//.test(id)) return "auth";
+  if (/app\/\(admin\)\//.test(id)) return "admin";
+  if (/app\/\(settings\)\//.test(id)) return "settings";
+  if (/app\/\(app\)\/\[orgSlug\]\/\(project-pages\)\//.test(id)) return "project";
+  if (/app\/\(app\)\/\[orgSlug\]\/\(org-pages\)\//.test(id)) return "org";
+  if (/app\/\(app\)\/\[orgSlug\]\//.test(id)) return "org";
+  if (id.startsWith("app/integrations/")) return "integrations";
+  if (id.startsWith("app/docs/")) return "admin";
+  if (id.startsWith("client/components/ui/")) return "shared-ui";
+  if (id.startsWith("client/components/layout/") || /client\/lib\/navigation/.test(id)) return "layout";
+  if (/client\/components\/auth\//.test(id) || /client\/lib\/auth-/.test(id) || /client\/lib\/github-oauth/.test(id) || /client\/lib\/permission-service/.test(id) || /client\/hooks\/use-permissions/.test(id)) return "auth";
+  if (/client\/components\/prd-/.test(id) || /client\/hooks\/use-admin/.test(id)) return "admin";
+  if (/client\/components\/org-/.test(id) || /client\/hooks\/use-org-/.test(id) || /client\/hooks\/use-provider-def/.test(id)) return "org";
+  if (/client\/components\/project/.test(id) || /client\/hooks\/use-project-/.test(id) || /client\/hooks\/use-pipeline/.test(id) || /client\/hooks\/use-databases/.test(id) || /client\/hooks\/use-provider-env/.test(id) || /client\/hooks\/use-role-assign/.test(id) || /client\/components\/pipeline/.test(id) || /client\/components\/deployments/.test(id)) return "project";
+  if (/client\/hooks\/use-(profile|sessions|organizations|notification)/.test(id)) return "settings";
+  if (id.startsWith("server/auth/")) return "auth";
+  if (id.startsWith("server/mcp/")) return "mcp";
+  if (id.startsWith("server/lib/")) return "server-lib";
+  if (id.startsWith("server/middleware")) return "middleware";
+  if (id.startsWith("server/services/")) return "services";
+  if (id.startsWith("server/db")) return "db";
+  if (id.startsWith("server/errors")) return "errors";
+  if (id.startsWith("server/")) return "server-lib";
+  if (id.startsWith("config/")) return "config";
+  if (id.startsWith("lib/")) return "lib";
+  return "root";
+}
+function extractRoute(id) {
+  if (!id.endsWith("/page.tsx")) return null;
+  let route = id.replace(/^app\//, "/").replace(/\/page\.tsx$/, "");
+  route = route.replace(/\/\([^)]+\)/g, "");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  route = route.replace(/\/+/g, "/");
+  if (!route.startsWith("/")) route = "/" + route;
+  return route || "/";
+}
+function nameFromFilename(absPath) {
+  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) => {
+    const cleaned = expr.trim();
+    if (cleaned.includes(".")) {
+      const parts = cleaned.split(".");
+      const last = parts[parts.length - 1];
+      const secondLast = parts.length > 1 ? parts[parts.length - 2] : "";
+      if (last === "slug" && secondLast === "project") return ":projectSlug";
+      if (last === "slug") return ":projectSlug";
+      if (last === "id" && /cred/i.test(secondLast)) return ":credentialId";
+      if (last === "id" && /run/i.test(secondLast)) return ":runId";
+      if (last === "sha") return ":commitSha";
+      if (last === "id") return ":id";
+      return `:${last}`;
+    }
+    if (/orgSlug/i.test(cleaned)) return ":orgSlug";
+    if (/projectSlug/i.test(cleaned)) return ":projectSlug";
+    if (/runId/i.test(cleaned)) return ":runId";
+    if (/credentialId/i.test(cleaned)) return ":credentialId";
+    if (/commitSha/i.test(cleaned)) return ":commitSha";
+    if (/token/i.test(cleaned)) return ":token";
+    return `:${cleaned}`;
+  });
+  const normalized = parameterized.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+  if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
+  let bestScore = -1;
+  let bestId = null;
+  for (const [route, nodeId] of routeToNodeId) {
+    const score = routeMatchScore(normalized, route);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = nodeId;
+    }
+  }
+  return bestScore > 0 ? bestId : null;
+}
+function routeMatchScore(candidate, known) {
+  const segsA = candidate.split("/");
+  const segsB = known.split("/");
+  if (segsA.length !== segsB.length) return -1;
+  let score = 0;
+  for (let i = 0; i < segsA.length; i++) {
+    const a = segsA[i], b = segsB[i];
+    if (a === b) {
+      score += 3;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      score += 0;
+      continue;
+    }
+    return -1;
+  }
+  return score;
+}
+function templateToRoute(template) {
+  return template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    const cleaned = expr.trim();
+    if (cleaned.includes(".")) {
+      const parts = cleaned.split(".");
+      const last = parts[parts.length - 1];
+      const secondLast = parts.length > 1 ? parts[parts.length - 2] : "";
+      if (last === "slug" && /project/i.test(secondLast)) return ":projectSlug";
+      if (last === "slug") return ":slug";
+      if (last === "sha") return ":commitSha";
+      return `:${last}`;
+    }
+    return `:${cleaned}`;
+  });
+}
+function matchRouteToPage(route, routeToNodeId) {
+  const normalized = route.replace(/\/$/, "") || "/";
+  if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
+  return null;
+}
+function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap, barrelMaps, routeToNodeId) {
+  const edges = [];
+  const flagged = [];
+  const seen = /* @__PURE__ */ new Set();
+  function addEdge(target, type, label) {
+    const key = `${sourceId}\u2192${target}\u2192${type}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const edge = { source: sourceId, target, type };
+    if (label) edge.label = label;
+    edges.push(edge);
+  }
+  function edgeTypeFor(targetId, isTypeOnlyImport, importedNames) {
+    if (isTypeOnlyImport) return "imports";
+    const targetType = nodeTypeMap.get(targetId);
+    if (targetType && RENDER_TYPES.has(targetType)) {
+      const anyRendered = importedNames.some((n) => parsed.jsxElements.has(n));
+      if (anyRendered) return "renders";
+    }
+    return "imports";
+  }
+  for (const imp of parsed.imports) {
+    const { names, specifier, isTypeOnly, typeNames } = imp;
+    if (specifier.startsWith("@/")) {
+      const relToSrc = specifier.slice(2);
+      const barrelMap = barrelMaps.get(relToSrc);
+      if (barrelMap && names.length > 0) {
+        const byTarget = /* @__PURE__ */ new Map();
+        for (const name of names) {
+          const targetAbs = barrelMap.get(name);
+          if (targetAbs) {
+            const targetId = toNodeId(srcDir, targetAbs);
+            if (nodeIdSet.has(targetId)) {
+              if (!byTarget.has(targetId)) byTarget.set(targetId, []);
+              byTarget.get(targetId).push(name);
+            }
+          }
+        }
+        for (const [targetId, targetNames] of byTarget) {
+          const allType = isTypeOnly || targetNames.every((n) => typeNames.has(n));
+          addEdge(targetId, edgeTypeFor(targetId, allType, targetNames));
+        }
+      } else {
+        const resolved = resolveImport(srcDir, specifier);
+        if (resolved) {
+          const targetId = toNodeId(srcDir, resolved);
+          if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
+            addEdge(targetId, edgeTypeFor(targetId, isTypeOnly, names));
+          }
+        }
+      }
+    } else if (specifier.startsWith(".")) {
+      const resolved = resolveRelativeImport(absPath, specifier);
+      if (resolved) {
+        const targetId = toNodeId(srcDir, resolved);
+        if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
+          addEdge(targetId, edgeTypeFor(targetId, isTypeOnly, names));
+        }
+      }
+    }
+  }
+  for (const nav of parsed.navigations) {
+    if (nav.kind === "window-location") {
+      flagged.push({
+        source: sourceId,
+        target: "EXTERNAL",
+        type: "navigates",
+        label: `window.location to ${nav.target}`,
+        confidence: "high"
+      });
+      continue;
+    }
+    if (!nav.isTemplate) {
+      const targetId = matchRouteToPage(nav.target, routeToNodeId);
+      if (targetId && targetId !== sourceId) {
+        const label = nav.kind === "link-href" ? `Link to ${nav.target}` : `router.${nav.kind === "router-push" ? "push" : "replace"}('${nav.target}')`;
+        addEdge(targetId, "navigates", label);
+      }
+    } else {
+      const template = nav.target.replace(/^`|`$/g, "");
+      if (!template.includes("${")) continue;
+      const targetId = resolveTemplateLiteralRoute(template, routeToNodeId);
+      if (targetId && targetId !== sourceId) {
+        const label = nav.kind === "link-href" ? `Link to ${templateToRoute(template)}` : `router.${nav.kind === "router-push" ? "push" : "replace"}('${templateToRoute(template)}')`;
+        addEdge(targetId, "navigates", label);
+      } else {
+        flagged.push({
+          source: sourceId,
+          target: "DYNAMIC",
+          type: "navigates",
+          label: nav.kind === "link-href" ? `Link with template: \`${template}\`` : `router.${nav.kind === "router-push" ? "push" : "replace"} with template: \`${template}\``,
+          confidence: "medium"
+        });
+      }
+    }
+  }
+  return { edges, flagged };
+}
+function detect(rootDir) {
+  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_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_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_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_path3.basename)(f).startsWith("index."));
+  const nodes = [];
+  const nodeIdSet = /* @__PURE__ */ new Set();
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  const routeToNodeId = /* @__PURE__ */ new Map();
+  for (const absPath of fileSet) {
+    const id = toNodeId(srcDir, absPath);
+    const type = classifyType(id);
+    const parsed = parsedByPath.get(absPath);
+    const name = parsed.name || nameFromFilename(absPath);
+    const route = extractRoute(id);
+    const module_ = classifyModule(id);
+    nodes.push({ id, type, name, route, module: module_, exports: parsed.exports });
+    nodeIdSet.add(id);
+    nodeTypeMap.set(id, type);
+    if (route) routeToNodeId.set(route, id);
+  }
+  const allEdges = [];
+  const allFlagged = [];
+  for (const absPath of fileSet) {
+    const sourceId = toNodeId(srcDir, absPath);
+    const parsed = parsedByPath.get(absPath);
+    const { edges, flagged } = extractEdges(
+      srcDir,
+      absPath,
+      sourceId,
+      parsed,
+      nodeIdSet,
+      nodeTypeMap,
+      barrelMaps,
+      routeToNodeId
+    );
+    allEdges.push(...edges);
+    allFlagged.push(...flagged);
+  }
+  const fetchCallEntries = [];
+  for (const absPath of fileSet) {
+    const sourceId = toNodeId(srcDir, absPath);
+    const parsed = parsedByPath.get(absPath);
+    if (parsed.fetchCalls.length === 0) continue;
+    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([
+    "node_modules",
+    ".next",
+    "dist",
+    ".launchsecure",
+    ".git",
+    "src",
+    "coverage",
+    ".turbo",
+    "build",
+    "out",
+    ".vercel"
+  ]);
+  const externalCandidates = walkWithIgnore(rootDir, [".ts", ".tsx"], IGNORE_DIRS);
+  for (const absPath of externalCandidates) {
+    const normalized = absPath.replace(/\\/g, "/");
+    if (externalScanned.has(normalized)) continue;
+    let parsed;
+    try {
+      parsed = parseFile(absPath);
+    } catch {
+      continue;
+    }
+    const externalId = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const edgesFromThis = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const imp of parsed.imports) {
+      const { specifier, isTypeOnly, names } = imp;
+      let resolved = null;
+      if (specifier.startsWith("@/")) {
+        const relToSrc = specifier.slice(2);
+        const barrelMap = barrelMaps.get(relToSrc);
+        if (barrelMap && names.length > 0) {
+          for (const name of names) {
+            const targetAbs = barrelMap.get(name);
+            if (!targetAbs) continue;
+            const targetId2 = toNodeId(srcDir, targetAbs);
+            if (!nodeIdSet.has(targetId2)) continue;
+            const key2 = `${externalId}\u2192${targetId2}`;
+            if (seen.has(key2)) continue;
+            seen.add(key2);
+            edgesFromThis.push({ source: externalId, target: targetId2, type: "imports" });
+          }
+          continue;
+        }
+        resolved = resolveImport(srcDir, specifier);
+      } else if (specifier.startsWith(".")) {
+        resolved = resolveRelativeImport(absPath, specifier);
+      }
+      if (!resolved) continue;
+      const targetId = toNodeId(srcDir, resolved);
+      if (!nodeIdSet.has(targetId)) continue;
+      if (targetId.endsWith("/index.ts") || targetId.endsWith("/index.tsx")) continue;
+      const key = `${externalId}\u2192${targetId}\u2192${isTypeOnly ? "type" : "value"}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edgesFromThis.push({ source: externalId, target: targetId, type: "imports" });
+    }
+    if (edgesFromThis.length === 0) continue;
+    nodes.push({
+      id: externalId,
+      type: "external",
+      name: parsed.name || nameFromFilename(absPath),
+      route: null,
+      module: "external",
+      exports: parsed.exports
+    });
+    nodeIdSet.add(externalId);
+    nodeTypeMap.set(externalId, "external");
+    allEdges.push(...edgesFromThis);
+  }
+  const flaggedSet = /* @__PURE__ */ new Set();
+  const dedupedFlagged = allFlagged.filter((f) => {
+    const key = `${f.source}\u2192${f.target}\u2192${f.label}`;
+    if (flaggedSet.has(key)) return false;
+    flaggedSet.add(key);
+    return true;
+  });
+  const typePriority = {
+    layout: 0,
+    page: 1,
+    component: 2,
+    ui: 3,
+    context: 4,
+    config: 5,
+    util: 6,
+    hook: 7,
+    lib: 8
+  };
+  nodes.sort((a, b) => (typePriority[a.type] ?? 99) - (typePriority[b.type] ?? 99) || a.id.localeCompare(b.id));
+  allEdges.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  const byType = (t) => nodes.filter((n) => n.type === t).length;
+  const stats = {
+    total_pages: byType("page"),
+    total_layouts: byType("layout"),
+    total_components: byType("component"),
+    total_ui: byType("ui"),
+    total_hooks: byType("hook"),
+    total_contexts: byType("context"),
+    total_configs: byType("config"),
+    total_utils: byType("util"),
+    total_libs: byType("lib"),
+    total_external: byType("external"),
+    total_edges: allEdges.length,
+    total_flagged: dedupedFlagged.length
+  };
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "main-app-only",
+      app_root: "src/",
+      layer: "ui",
+      parser: "react-nextjs-ast",
+      ...stats,
+      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: [],
+    contradictions: [],
+    warnings: [],
+    flagged_edges: dedupedFlagged,
+    patterns: {
+      total_nodes: nodes.length,
+      by_type: stats,
+      by_edge_type: {
+        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
+    }
+  };
+}
+var reactNextjsParser = {
+  id: "react-nextjs",
+  layer: "ui",
+  detect,
+  generate
+};
+
+// src/server/graph/parsers/api/nextjs-routes.ts
+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_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") {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function filePathToRoute(apiDir, absPath) {
+  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";
+  return "/api" + route;
+}
+function camelToPascal(s) {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function detect2(rootDir) {
+  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "src", "app", "api"));
+}
+function generate2(rootDir) {
+  const apiDir = (0, import_node_path4.join)(rootDir, "src", "app", "api");
+  const routeFiles = walk2(apiDir);
+  const nodes = [];
+  const edges = [];
+  const crossRefs = [];
+  const mutatorCount = {};
+  const authUsage = {};
+  let endpointsWithAuth = 0;
+  let endpointsWithDbAccess = 0;
+  for (const absPath of routeFiles) {
+    const parsed = parseFile(absPath);
+    const dbCalls = extractDbCalls(absPath);
+    const authWrappers = extractAuthWrappers(absPath);
+    const methods = [];
+    for (const exp of parsed.exports) {
+      if (HTTP_METHODS2.has(exp)) methods.push(exp);
+    }
+    const routePath = filePathToRoute(apiDir, absPath);
+    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;
+    if (mutates) {
+      for (const m of mutations) {
+        mutatorCount[m.method] = (mutatorCount[m.method] ?? 0) + 1;
+      }
+    }
+    if (dbCalls.length > 0) endpointsWithDbAccess++;
+    const authStrategy = [];
+    for (const w of authWrappers) {
+      authStrategy.push(w);
+      authUsage[w] = (authUsage[w] ?? 0) + 1;
+    }
+    if (authStrategy.length > 0) endpointsWithAuth++;
+    nodes.push({
+      id: relPath,
+      type: "endpoint",
+      name: routePath,
+      path: routePath,
+      methods,
+      handler: relPath,
+      // Behavioral classification from handler body (AST-derived).
+      mutates,
+      auth: authStrategy.length > 0 ? authStrategy : ["public"],
+      db_models: [...new Set(dbCalls.map((c) => c.model))],
+      db_operations: [...new Set(dbCalls.map((c) => `${c.model}.${c.method}`))]
+    });
+    const seenModels = /* @__PURE__ */ new Set();
+    for (const call of dbCalls) {
+      if (seenModels.has(call.model)) continue;
+      seenModels.add(call.model);
+      crossRefs.push({
+        source: relPath,
+        target: camelToPascal(call.model),
+        type: call.isMutation ? "mutates" : "reads",
+        layer: "db"
+      });
+    }
+  }
+  nodes.sort((a, b) => a.path.localeCompare(b.path));
+  crossRefs.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  const mutatorNodes = nodes.filter((n) => n.mutates).length;
+  const readOnlyNodes = nodes.filter((n) => !n.mutates).length;
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "main-app-only",
+      stack: "nextjs-app-router",
+      layer: "api",
+      parser: "nextjs-routes-ast",
+      total_endpoints: nodes.length,
+      total_methods: nodes.reduce((sum, n) => sum + n.methods.length, 0),
+      endpoints_with_auth: endpointsWithAuth,
+      endpoints_with_db_access: endpointsWithDbAccess,
+      mutator_endpoints: mutatorNodes,
+      read_only_endpoints: readOnlyNodes
+    },
+    nodes,
+    edges,
+    cross_refs: crossRefs,
+    contradictions: [],
+    warnings: [],
+    flagged_edges: [],
+    patterns: {
+      total_endpoints: nodes.length,
+      methods_breakdown: [...HTTP_METHODS2].reduce((acc, m) => {
+        acc[m] = nodes.filter((n) => n.methods.includes(m)).length;
+        return acc;
+      }, {}),
+      auth_strategies: authUsage,
+      mutation_operations: mutatorCount,
+      mutator_vs_reader: { mutators: mutatorNodes, readers: readOnlyNodes }
+    }
+  };
+}
+var nextjsRoutesParser = {
+  id: "nextjs-routes",
+  layer: "api",
+  detect: detect2,
+  generate: generate2
+};
+
+// src/server/graph/parsers/db/prisma-schema.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
+function parseModels(content) {
+  const nodes = [];
+  const relations = [];
+  const modelRe = /model\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = modelRe.exec(content)) !== null) {
+    const modelName = m[1];
+    const body = m[2];
+    const columns = [];
+    const lines = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("@@"));
+    for (const line of lines) {
+      const fieldMatch = line.match(/^(\w+)\s+(\S+)(.*)/);
+      if (!fieldMatch) continue;
+      const fieldName = fieldMatch[1];
+      const fieldType = fieldMatch[2];
+      const rest = fieldMatch[3] ?? "";
+      const commentMatch = rest.match(/\/\/\s*(.+)$/);
+      const comment = commentMatch ? commentMatch[1].trim() : null;
+      const restNoComment = commentMatch ? rest.slice(0, commentMatch.index).trim() : rest;
+      const isPrimary = restNoComment.includes("@id");
+      const isUnique = restNoComment.includes("@unique");
+      const isNullable = fieldType.endsWith("?");
+      const baseType = fieldType.replace(/[?\[\]]/g, "");
+      const defaultMatch = restNoComment.match(/@default\(([^)]+)\)/);
+      const defaultVal = defaultMatch ? defaultMatch[1] : null;
+      const relationMatch = restNoComment.match(/@relation\(([^)]*)\)/);
+      const isRelationField = !!relationMatch;
+      columns.push({
+        name: fieldName,
+        type: fieldType,
+        primary: isPrimary,
+        unique: isUnique,
+        nullable: isNullable,
+        default: defaultVal,
+        isRelation: isRelationField,
+        comment
+      });
+      if (relationMatch) {
+        const relArgs = relationMatch[1];
+        const fieldsMatch = relArgs.match(/fields:\s*\[([^\]]+)\]/);
+        const refsMatch = relArgs.match(/references:\s*\[([^\]]+)\]/);
+        const onDeleteMatch = relArgs.match(/onDelete:\s*(\w+)/);
+        if (fieldsMatch && refsMatch) {
+          const fk = fieldsMatch[1].trim();
+          relations.push({
+            source: modelName,
+            target: baseType,
+            type: "belongs_to",
+            fk,
+            onDelete: onDeleteMatch ? onDeleteMatch[1] : null
+          });
+        }
+      }
+      if (fieldType.endsWith("[]") && !relationMatch) {
+        relations.push({
+          source: modelName,
+          target: baseType,
+          type: "has_many",
+          fk: null,
+          onDelete: null
+        });
+      }
+    }
+    nodes.push({
+      id: modelName,
+      type: "table",
+      name: modelName,
+      columns: columns.filter((c) => !c.isRelation || c.primary)
+    });
+  }
+  return { nodes, relations };
+}
+function parseEnums(content) {
+  const nodes = [];
+  const enumRe = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = enumRe.exec(content)) !== null) {
+    const enumName = m[1];
+    const body = m[2];
+    const values = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//"));
+    nodes.push({
+      id: enumName,
+      type: "enum",
+      name: enumName,
+      values
+    });
+  }
+  return nodes;
+}
+function detect3(rootDir) {
+  return (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "prisma", "schema.prisma"));
+}
+function generate3(rootDir) {
+  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];
+  const edges = relations.map((r) => ({
+    source: r.source,
+    target: r.target,
+    type: r.type,
+    fk: r.fk,
+    onDelete: r.onDelete
+  }));
+  allNodes.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "table" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  edges.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "prisma-schema",
+      source: "prisma/schema.prisma",
+      provider: "postgresql",
+      layer: "db",
+      total_models: modelNodes.length,
+      total_enums: enumNodes.length,
+      total_relations: edges.length
+    },
+    nodes: allNodes,
+    edges,
+    cross_refs: [],
+    contradictions: [],
+    warnings: [
+      {
+        type: "schema_file_only",
+        detail: "Live DB introspection not yet implemented. Graph derived from prisma/schema.prisma."
+      }
+    ],
+    flagged_edges: [],
+    patterns: {
+      total_tables: modelNodes.length,
+      total_enums: enumNodes.length,
+      total_relations: edges.length,
+      relation_types: {
+        belongs_to: edges.filter((e) => e.type === "belongs_to").length,
+        has_many: edges.filter((e) => e.type === "has_many").length
+      }
+    }
+  };
+}
+var prismaSchemaParser = {
+  id: "prisma-schema",
+  layer: "db",
+  detect: detect3,
+  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
+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 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: merged,
+    nodeCount: merged.nodes.length,
+    edgeCount: merged.edges.length
+  };
+}
+function generateAll(rootDir) {
+  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 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);
+}
+
+// src/server/graph/index.ts
+var GRAPHS_DIR = ".launchsecure/graphs";
+var LAYERS = ["ui", "api", "db"];
+var graphCache = /* @__PURE__ */ new Map();
+function graphsDir(rootDir) {
+  return (0, import_node_path10.join)(rootDir, GRAPHS_DIR);
+}
+function graphFilePath(rootDir, layer) {
+  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_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_fs9.readFileSync)(filePath, "utf-8");
+  const graph = JSON.parse(content);
+  graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
+  return graph;
+}
+function readAllGraphs(rootDir) {
+  const result = {};
+  for (const layer of LAYERS) {
+    const graph = readGraph(rootDir, layer);
+    if (graph) result[layer] = graph;
+  }
+  return result;
+}
+function generateGraph(rootDir, layer) {
+  const dir = graphsDir(rootDir);
+  (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_fs9.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
+    invalidateCache(filePath);
+  }
+  return results;
+}
+
+// src/server/lockfile.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs10 = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path11 = require("node:path");
+function lockDir() {
+  return (0, import_node_path11.join)((0, import_node_os.homedir)(), ".launchsecure");
+}
+function lockPath() {
+  return (0, import_node_path11.join)(lockDir(), "launch-chart.lock");
+}
+function readLock() {
+  const p = lockPath();
+  if (!(0, import_node_fs10.existsSync)(p)) return null;
+  try {
+    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 {
+    return null;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getListenerPid(port) {
+  try {
+    const out = (0, import_node_child_process.execFileSync)("lsof", ["-nP", "-iTCP:" + port, "-sTCP:LISTEN", "-t"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 500
+    }).trim();
+    if (!out) return null;
+    const pid = parseInt(out.split("\n")[0], 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function getLiveLock() {
+  const lock = readLock();
+  if (!lock) return null;
+  const listenerPid = getListenerPid(lock.port);
+  const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
+  if (!live) {
+    try {
+      (0, import_node_fs10.unlinkSync)(lockPath());
+    } catch {
+    }
+    return null;
+  }
+  return lock;
+}
+function writeLock(data) {
+  (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_fs10.unlinkSync)(lockPath());
+  } catch {
+  }
+}
+
+// src/server/chart-serve.ts
+var DEFAULT_PORT = 52819;
+var MAX_PORT_SCAN = 20;
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 8; i++) {
+    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_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;
+  }
+  return startDir;
+}
+function buildMergedGraph(projectRoot) {
+  let graphs = readAllGraphs(projectRoot);
+  if (!graphs.ui && !graphs.api && !graphs.db) {
+    generateGraph(projectRoot);
+    graphs = readAllGraphs(projectRoot);
+  }
+  const nodes = [];
+  const rawLinks = [];
+  const LAYERS2 = ["ui", "api", "db"];
+  for (const layer of LAYERS2) {
+    const g = graphs[layer];
+    if (!g) continue;
+    for (const n of g.nodes) {
+      nodes.push({
+        id: `${layer}:${n.id}`,
+        name: n.name,
+        type: n.type,
+        layer,
+        module: n.module ?? null,
+        path: n.path ?? n.id
+      });
+    }
+    for (const e of g.edges) {
+      rawLinks.push({ source: `${layer}:${e.source}`, target: `${layer}:${e.target}`, type: e.type, layer, cross: false });
+    }
+    for (const c of g.cross_refs ?? []) {
+      rawLinks.push({ source: `${layer}:${c.source}`, target: `${c.layer}:${c.target}`, type: c.type, layer, cross: true });
+    }
+  }
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const links = rawLinks.filter((l) => nodeIds.has(l.source) && nodeIds.has(l.target));
+  return {
+    nodes,
+    links,
+    stats: {
+      nodes: nodes.length,
+      links: links.length,
+      byLayer: {
+        ui: graphs.ui ? graphs.ui.nodes.length : 0,
+        api: graphs.api ? graphs.api.nodes.length : 0,
+        db: graphs.db ? graphs.db.nodes.length : 0
+      }
+    }
+  };
+}
+function serveStatic(res, filePath) {
+  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_fs11.default.createReadStream(filePath).pipe(res);
+  return true;
+}
+function serveIndex(res, clientDir) {
+  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;
+  }
+  serveStatic(res, indexPath);
+}
+function tryListen(server, port) {
+  return new Promise((resolve2, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve2(port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
+}
+async function bindWithFallback(server, startPort) {
+  let lastErr = null;
+  for (let i = 0; i < MAX_PORT_SCAN; i++) {
+    const port = startPort + i;
+    try {
+      return await tryListen(server, port);
+    } catch (err) {
+      const code = err.code;
+      if (code === "EADDRINUSE") {
+        lastErr = err;
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastErr ?? new Error("Failed to bind any port");
+}
+async function startChartServer(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(cwd);
+  const existing = getLiveLock();
+  if (existing) {
+    if (!opts.quiet) {
+      process.stderr.write(
+        `[launch-chart] already running (pid ${existing.pid}) at ${existing.url}
+`
+      );
+    }
+    return { port: existing.port, url: existing.url };
+  }
+  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}`);
+      if (req.method === "GET" && url2.pathname === "/api/project-graph") {
+        const regenerate = url2.searchParams.get("regenerate") === "1";
+        if (regenerate) generateGraph(projectRoot);
+        const merged = buildMergedGraph(projectRoot);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          ...merged,
+          debug: { cwd, projectRoot }
+        }));
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/raw-graphs") {
+        const graphs = readAllGraphs(projectRoot);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ui: graphs.ui ?? null, api: graphs.api ?? null, db: graphs.db ?? null }));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/generate-graph") {
+        try {
+          generateGraph(projectRoot);
+          const graphs = readAllGraphs(projectRoot);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            ok: true,
+            ui: graphs.ui ?? null,
+            api: graphs.api ?? null,
+            db: graphs.db ?? null
+          }));
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: String(err) }));
+        }
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        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_path12.default.join(clientDir, url2.pathname);
+        if (serveStatic(res, staticPath)) return;
+      }
+      serveIndex(res, clientDir);
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: String(err) }));
+    }
+  });
+  const port = await bindWithFallback(server, opts.port ?? DEFAULT_PORT);
+  const url = `http://localhost:${port}`;
+  writeLock({
+    pid: process.pid,
+    port,
+    cwd,
+    url,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const cleanup = () => {
+    clearLock();
+    server.close();
+  };
+  process.once("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.once("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.once("exit", cleanup);
+  if (!opts.quiet) {
+    process.stderr.write(`[launch-chart] serving ${url}
+`);
+    process.stderr.write(`[launch-chart] project root: ${projectRoot}
+`);
+  }
+  return { port, url };
+}
+function runServeCli(argv) {
+  let port;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--port" && argv[i + 1]) {
+      port = parseInt(argv[++i], 10);
+    } else if (argv[i].startsWith("--port=")) {
+      port = parseInt(argv[i].slice("--port=".length), 10);
+    }
+  }
+  startChartServer({ port }).catch((err) => {
+    process.stderr.write(`[launch-chart] failed to start: ${err}
+`);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runServeCli,
+  startChartServer
+});