@launchsecure/launch-kit 0.0.18 → 0.0.20

package/dist/server/chart-serve.js

@@ -602,19 +602,19 @@ __export(chart_serve_exports, {
 module.exports = __toCommonJS(chart_serve_exports);
 var import_node_http = __toESM(require("node:http"));
 var import_node_fs18 = __toESM(require("node:fs"));
-var import_node_path20 = __toESM(require("node:path"));
+var import_node_path19 = __toESM(require("node:path"));
 
 // src/server/graph/index.ts
 var import_node_fs15 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_path16 = require("node:path");
 
 // src/server/graph/core/graph-builder.ts
 var import_node_fs12 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_path12 = require("node:path");
 init_config();
 
 // src/server/graph/core/parser-registry.ts
-var import_node_path12 = require("node:path");
+var import_node_path11 = require("node:path");
 
 // src/server/graph/parsers/ts/typescript-project.ts
 var import_node_fs5 = require("node:fs");
@@ -622,35 +622,12 @@ var import_node_path5 = require("node:path");
 init_config();
 
 // src/server/graph/core/resolve-paths.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path2 = require("node:path");
-function detectDbDir(rootDir, config) {
-  if (config.paths?.dbDir) return (0, import_node_path2.join)(rootDir, config.paths.dbDir);
-  const prismaDir = (0, import_node_path2.join)(rootDir, "prisma");
-  if ((0, import_node_fs2.existsSync)(prismaDir)) return prismaDir;
-  return null;
-}
-function resolveProjectPaths(rootDir, config) {
-  const dbDir = detectDbDir(rootDir, config);
-  if (config.paths?.appDir) {
-    const appDir = (0, import_node_path2.join)(rootDir, config.paths.appDir);
-    const srcDir = config.paths.srcDir ? (0, import_node_path2.join)(rootDir, config.paths.srcDir) : (0, import_node_path2.dirname)(appDir);
-    return { srcDir, appDir, apiDir: (0, import_node_path2.join)(appDir, "api"), dbDir };
-  }
-  const srcApp = (0, import_node_path2.join)(rootDir, "src", "app");
-  if ((0, import_node_fs2.existsSync)(srcApp)) {
-    return { srcDir: (0, import_node_path2.join)(rootDir, "src"), appDir: srcApp, apiDir: (0, import_node_path2.join)(srcApp, "api"), dbDir };
-  }
-  const rootApp = (0, import_node_path2.join)(rootDir, "app");
-  if ((0, import_node_fs2.existsSync)(rootApp)) {
-    return { srcDir: rootDir, appDir: rootApp, apiDir: (0, import_node_path2.join)(rootApp, "api"), dbDir };
-  }
-  return null;
-}
-
-// src/server/graph/core/walk.ts
 var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
+
+// src/server/graph/core/walk.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
 var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -666,12 +643,12 @@ var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
 ]);
 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 (!(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 (entry.isDirectory()) {
       results.push(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
       results.push(full);
     }
   }
@@ -679,19 +656,205 @@ function walk(dir, exts) {
 }
 function walkWithIgnore(dir, exts, opts = {}) {
   const results = [];
-  if (!(0, import_node_fs3.existsSync)(dir)) return results;
+  if (!(0, import_node_fs2.existsSync)(dir)) return results;
   const skip = opts.extraIgnore ? /* @__PURE__ */ new Set([...DEFAULT_IGNORE_DIRS, ...opts.extraIgnore]) : DEFAULT_IGNORE_DIRS;
-  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (skip.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path3.join)(dir, entry.name), exts, opts));
-    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
-      results.push((0, import_node_path3.join)(dir, entry.name));
+      results.push(...walkWithIgnore((0, import_node_path2.join)(dir, entry.name), exts, opts));
+    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
+      results.push((0, import_node_path2.join)(dir, entry.name));
     }
   }
   return results;
 }
 
+// src/server/graph/core/resolve-paths.ts
+function hasSqlFiles(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return false;
+  try {
+    return (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isFile() && e.name.endsWith(".sql")
+    );
+  } catch {
+    return false;
+  }
+}
+function hasNestedMigrationSql(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return false;
+  try {
+    return (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isDirectory() && (0, import_node_fs3.existsSync)((0, import_node_path3.join)(dir, e.name, "migration.sql"))
+    );
+  } catch {
+    return false;
+  }
+}
+function resolveDbFromDir(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
+  const schemaPath = (0, import_node_path3.join)(dir, "schema.prisma");
+  if ((0, import_node_fs3.existsSync)(schemaPath)) {
+    const migrationsDir2 = (0, import_node_path3.join)(dir, "migrations");
+    return {
+      kind: "prisma",
+      schemaPath,
+      migrationsDir: (0, import_node_fs3.existsSync)(migrationsDir2) ? migrationsDir2 : null
+    };
+  }
+  const migrationsDir = (0, import_node_path3.join)(dir, "migrations");
+  if (hasSqlFiles(migrationsDir) || hasNestedMigrationSql(migrationsDir)) {
+    return { kind: "sql-migrations", migrationsDir, schemaPath: null };
+  }
+  if (hasSqlFiles(dir) || hasNestedMigrationSql(dir)) {
+    return { kind: "sql-migrations", migrationsDir: dir, schemaPath: null };
+  }
+  return { kind: "none", schemaPath: null, migrationsDir: null };
+}
+function detectDbConfig(rootDir, config) {
+  if (config.paths?.dbDir) {
+    return resolveDbFromDir((0, import_node_path3.join)(rootDir, config.paths.dbDir));
+  }
+  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path3.join)("db", "migrations"), "migrations"];
+  for (const c of candidates) {
+    const dir = (0, import_node_path3.join)(rootDir, c);
+    const resolved = resolveDbFromDir(dir);
+    if (resolved.kind !== "none") return resolved;
+  }
+  return { kind: "none", schemaPath: null, migrationsDir: null };
+}
+function detectDbDir(rootDir, config, dbConfig) {
+  if (config.paths?.dbDir) return (0, import_node_path3.join)(rootDir, config.paths.dbDir);
+  if (dbConfig.kind === "prisma") return (0, import_node_path3.dirname)(dbConfig.schemaPath);
+  if (dbConfig.kind === "sql-migrations") return dbConfig.migrationsDir;
+  return null;
+}
+var NON_SOURCE_DIRS = /* @__PURE__ */ new Set([
+  ...DEFAULT_IGNORE_DIRS,
+  // DB conventions (handled by db parsers)
+  "prisma",
+  "supabase",
+  "drizzle",
+  "migrations",
+  // Web assets
+  "public",
+  "static",
+  "assets",
+  // Docs
+  "docs",
+  "documentation",
+  // Test dirs (project tests aren't part of the structural graph)
+  "tests",
+  "__tests__",
+  "e2e",
+  "playwright",
+  "cypress",
+  // Monorepo workspace roots — separate graph projects per .launchchart.json
+  "packages",
+  "apps",
+  "services",
+  "libs"
+]);
+function dirHasTSFiles(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return false;
+  try {
+    const stack = [dir];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      const entries = (0, import_node_fs3.readdirSync)(cur, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx"))) return true;
+        if (e.isDirectory() && !e.name.startsWith(".") && !DEFAULT_IGNORE_DIRS.has(e.name)) {
+          stack.push((0, import_node_path3.join)(cur, e.name));
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function collectCodeBearingChildren(dir, extraSkip) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return [];
+  const out = [];
+  try {
+    for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      if (NON_SOURCE_DIRS.has(entry.name)) continue;
+      if (extraSkip?.has(entry.name)) continue;
+      const full = (0, import_node_path3.join)(dir, entry.name);
+      if (dirHasTSFiles(full)) out.push(full);
+    }
+  } catch {
+  }
+  return out;
+}
+function detectSrcRoots(rootDir, srcDir, appDir, config) {
+  if (config.paths?.srcRoots && config.paths.srcRoots.length > 0) {
+    const roots2 = /* @__PURE__ */ new Set();
+    roots2.add(appDir);
+    for (const r of config.paths.srcRoots) {
+      const abs = (0, import_node_path3.isAbsolute)(r) ? r : (0, import_node_path3.resolve)(rootDir, r);
+      roots2.add(abs);
+    }
+    return [...roots2];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  roots.add(appDir);
+  for (const c of collectCodeBearingChildren(srcDir)) roots.add(c);
+  if (srcDir !== rootDir) {
+    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path3.basename)(srcDir)]);
+    for (const c of collectCodeBearingChildren(rootDir, skipSrcWrapper)) roots.add(c);
+  }
+  return [...roots];
+}
+var CONVENTION_NAMES = ["middleware.ts", "middleware.tsx", "instrumentation.ts", "instrumentation.tsx"];
+function detectConventionFiles(rootDir, srcDir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dirs = srcDir === rootDir ? [rootDir] : [srcDir, rootDir];
+  for (const dir of dirs) {
+    for (const name of CONVENTION_NAMES) {
+      const full = (0, import_node_path3.join)(dir, name);
+      if (!seen.has(full) && (0, import_node_fs3.existsSync)(full)) {
+        try {
+          if ((0, import_node_fs3.statSync)(full).isFile()) {
+            seen.add(full);
+            out.push(full);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return out;
+}
+function resolveProjectPaths(rootDir, config) {
+  let srcDir;
+  let appDir;
+  if (config.paths?.appDir) {
+    appDir = (0, import_node_path3.join)(rootDir, config.paths.appDir);
+    srcDir = config.paths.srcDir ? (0, import_node_path3.join)(rootDir, config.paths.srcDir) : (0, import_node_path3.dirname)(appDir);
+  } else {
+    const srcApp = (0, import_node_path3.join)(rootDir, "src", "app");
+    const rootApp = (0, import_node_path3.join)(rootDir, "app");
+    if ((0, import_node_fs3.existsSync)(srcApp)) {
+      srcDir = (0, import_node_path3.join)(rootDir, "src");
+      appDir = srcApp;
+    } else if ((0, import_node_fs3.existsSync)(rootApp)) {
+      srcDir = rootDir;
+      appDir = rootApp;
+    } else {
+      return null;
+    }
+  }
+  const apiDir = (0, import_node_path3.join)(appDir, "api");
+  const dbConfig = detectDbConfig(rootDir, config);
+  const dbDir = detectDbDir(rootDir, config, dbConfig);
+  const srcRoots = detectSrcRoots(rootDir, srcDir, appDir, config);
+  const conventionFiles = detectConventionFiles(rootDir, srcDir);
+  return { srcDir, appDir, apiDir, dbDir, srcRoots, conventionFiles, dbConfig };
+}
+
 // src/server/graph/parsers/ts/typescript-project.ts
 init_ts_extractor();
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
@@ -708,8 +871,12 @@ var CLASSIFICATION_TO_LAYER = {
   "mcp-tool": "ui",
   external: "ui"
 };
-function toNodeId(srcDir, absPath) {
-  return (0, import_node_path5.relative)(srcDir, absPath).replace(/\\/g, "/");
+function toNodeId(srcDir, rootDir, absPath) {
+  const relFromSrc = (0, import_node_path5.relative)(srcDir, absPath).replace(/\\/g, "/");
+  if (relFromSrc.startsWith("..")) {
+    return (0, import_node_path5.relative)(rootDir, absPath).replace(/\\/g, "/");
+  }
+  return relFromSrc;
 }
 function resolveImport(srcDir, specifier) {
   if (!specifier.startsWith("@/")) return null;
@@ -799,12 +966,13 @@ function extractRoute(id) {
 function nameFromFilename(absPath) {
   return (0, import_node_path5.basename)(absPath, (0, import_node_path5.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
-function filePathToApiRoute(apiDir, absPath) {
-  let route = "/" + (0, import_node_path5.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
+function filePathToAppRoute(appDir, absPath) {
+  let route = ("/" + (0, import_node_path5.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
+  route = route.replace(/\/\([^)]+\)/g, "");
+  route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
   route = route.replace(/\[([^\]]+)\]/g, ":$1");
   route = route.replace(/\/+/g, "/");
-  if (route === "/") return "/api";
-  return "/api" + route;
+  return route === "" ? "/" : route;
 }
 function camelToPascal(s) {
   if (!s) return s;
@@ -889,7 +1057,7 @@ function matchRouteToPage(route, routeToNodeId) {
   if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
   return null;
 }
-function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps, routeToNodeId) {
+function extractEdges(srcDir, rootDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps, routeToNodeId) {
   const edges = [];
   const flagged = [];
   const seen = /* @__PURE__ */ new Set();
@@ -917,7 +1085,7 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
         for (const name of names) {
           const targetAbs = barrelMap.get(name);
           if (targetAbs) {
-            const targetId = toNodeId(srcDir, targetAbs);
+            const targetId = toNodeId(srcDir, rootDir, targetAbs);
             if (nodeIdSet.has(targetId)) {
               if (!byTarget.has(targetId)) byTarget.set(targetId, []);
               byTarget.get(targetId).push(name);
@@ -931,7 +1099,7 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
       } else {
         const resolved = resolveImport(srcDir, specifier);
         if (resolved) {
-          const targetId = toNodeId(srcDir, resolved);
+          const targetId = toNodeId(srcDir, rootDir, resolved);
           if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
             addEdge(targetId, edgeTypeFor(isTypeOnly, names));
           }
@@ -940,7 +1108,7 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
     } else if (specifier.startsWith(".")) {
       const resolved = resolveRelativeImport(absPath, specifier);
       if (resolved) {
-        const targetId = toNodeId(srcDir, resolved);
+        const targetId = toNodeId(srcDir, rootDir, resolved);
         if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
           addEdge(targetId, edgeTypeFor(isTypeOnly, names));
         }
@@ -992,13 +1160,22 @@ function generate(rootDir) {
   const config = loadConfig(rootDir);
   const paths = resolveProjectPaths(rootDir, config);
   const srcDir = paths.srcDir;
-  const apiDir = paths.apiDir;
-  const appFiles = walk(paths.appDir, [".tsx", ".ts"]);
-  const clientFiles = walk((0, import_node_path5.join)(srcDir, "client"), [".tsx", ".ts"]);
-  const serverFiles = walk((0, import_node_path5.join)(srcDir, "server"), [".ts", ".tsx"]);
-  const libFiles = walk((0, import_node_path5.join)(srcDir, "lib"), [".ts", ".tsx"]);
-  const configFiles = walk((0, import_node_path5.join)(srcDir, "config"), [".ts", ".tsx"]);
-  const allDiscovered = [...appFiles, ...clientFiles, ...serverFiles, ...libFiles, ...configFiles];
+  const allDiscovered = [];
+  const discoveredSet = /* @__PURE__ */ new Set();
+  for (const root of paths.srcRoots) {
+    for (const f of walk(root, [".tsx", ".ts"])) {
+      if (!discoveredSet.has(f)) {
+        discoveredSet.add(f);
+        allDiscovered.push(f);
+      }
+    }
+  }
+  for (const conv of paths.conventionFiles) {
+    if (!discoveredSet.has(conv)) {
+      discoveredSet.add(conv);
+      allDiscovered.push(conv);
+    }
+  }
   const parsedByPath = /* @__PURE__ */ new Map();
   for (const absPath of allDiscovered) {
     parsedByPath.set(absPath, parseFileTS(absPath));
@@ -1010,7 +1187,7 @@ function generate(rootDir) {
   const routeToNodeId = /* @__PURE__ */ new Map();
   const fileSet = allDiscovered.filter((f) => !(0, import_node_path5.basename)(f).startsWith("index."));
   for (const absPath of fileSet) {
-    const id = toNodeId(srcDir, absPath);
+    const id = toNodeId(srcDir, rootDir, absPath);
     const type = classifyType(absPath, id);
     if (type === "test" || type === "story") continue;
     const parsed = parsedByPath.get(absPath);
@@ -1025,7 +1202,7 @@ function generate(rootDir) {
       const dbCalls = extractDbCallsTS(absPath);
       const authWrappers = extractAuthWrappersTS(absPath);
       const deep = extractDeep(absPath);
-      const routePath = (0, import_node_fs5.existsSync)(apiDir) ? filePathToApiRoute(apiDir, absPath) : `/api/${id.replace(/\/route\.tsx?$/, "")}`;
+      const routePath = filePathToAppRoute(paths.appDir, absPath);
       const mutations = dbCalls.filter((c) => c.isMutation);
       const mutates = mutations.length > 0;
       const authStrategy = [...authWrappers];
@@ -1069,11 +1246,12 @@ function generate(rootDir) {
   const uiEdges = [];
   const uiFlagged = [];
   for (const absPath of fileSet) {
-    const id = toNodeId(srcDir, absPath);
+    const id = toNodeId(srcDir, rootDir, absPath);
     if (!nodeIdSet.has(id)) continue;
     const parsed = parsedByPath.get(absPath);
     const { edges, flagged } = extractEdges(
       srcDir,
+      rootDir,
       absPath,
       id,
       parsed,
@@ -1086,7 +1264,7 @@ function generate(rootDir) {
   }
   const fetchCallEntries = [];
   for (const absPath of fileSet) {
-    const sourceId = toNodeId(srcDir, absPath);
+    const sourceId = toNodeId(srcDir, rootDir, absPath);
     if (!nodeIdSet.has(sourceId)) continue;
     const parsed = parsedByPath.get(absPath);
     if (parsed.fetchCalls.length === 0) continue;
@@ -1125,7 +1303,7 @@ function generate(rootDir) {
           for (const name of names) {
             const targetAbs = barrelMap.get(name);
             if (!targetAbs) continue;
-            const targetId2 = toNodeId(srcDir, targetAbs);
+            const targetId2 = toNodeId(srcDir, rootDir, targetAbs);
             if (!nodeIdSet.has(targetId2)) continue;
             const key2 = `${externalId}\u2192${targetId2}`;
             if (seen.has(key2)) continue;
@@ -1139,7 +1317,7 @@ function generate(rootDir) {
         resolved = resolveRelativeImport(absPath, specifier);
       }
       if (!resolved) continue;
-      const targetId = toNodeId(srcDir, resolved);
+      const targetId = toNodeId(srcDir, rootDir, resolved);
       if (!nodeIdSet.has(targetId)) continue;
       if (targetId.endsWith("/index.ts") || targetId.endsWith("/index.tsx")) continue;
       const key = `${externalId}\u2192${targetId}`;
@@ -1317,7 +1495,7 @@ var typescriptProjectParser = {
 
 // src/server/graph/parsers/db/prisma-schema.ts
 var import_node_fs6 = require("node:fs");
-var import_node_path6 = require("node:path");
+init_config();
 function parseModels(content) {
   const nodes = [];
   const relations = [];
@@ -1408,10 +1586,24 @@ function parseEnums(content) {
   return nodes;
 }
 function detect2(rootDir) {
-  return (0, import_node_fs6.existsSync)((0, import_node_path6.join)(rootDir, "prisma", "schema.prisma"));
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs6.existsSync)(paths.dbConfig.schemaPath);
 }
 function generate2(rootDir) {
-  const schemaPath = (0, import_node_path6.join)(rootDir, "prisma", "schema.prisma");
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (paths.dbConfig.kind !== "prisma") {
+    return {
+      metadata: { generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), layer: "db", source: "none" },
+      nodes: [],
+      edges: [],
+      cross_refs: [],
+      contradictions: [],
+      warnings: [],
+      flagged_edges: [],
+      patterns: { total_tables: 0, total_enums: 0, total_relations: 0 }
+    };
+  }
+  const schemaPath = paths.dbConfig.schemaPath;
   const content = (0, import_node_fs6.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
@@ -1432,7 +1624,7 @@ function generate2(rootDir) {
     metadata: {
       generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
       scope: "prisma-schema",
-      source: "prisma/schema.prisma",
+      source: schemaPath,
       provider: "postgresql",
       layer: "db",
       total_models: modelNodes.length,
@@ -1470,7 +1662,8 @@ var prismaSchemaParser = {
 
 // src/server/graph/parsers/db/sql-migrations.ts
 var import_node_fs7 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_path6 = require("node:path");
+init_config();
 var PG_TO_PRISMA = {
   "TEXT": "String",
   "VARCHAR": "String",
@@ -1501,51 +1694,149 @@ function pgTypeToPrisma(pgType) {
   const upper = pgType.toUpperCase().trim();
   return PG_TO_PRISMA[upper] ?? upper;
 }
+var ID = `(?:"[\\w$]+"|[\\w$]+)`;
+var QID = `(?:${ID}\\.)?${ID}`;
+function bareName(captured) {
+  const parts = captured.split(".");
+  const last = parts[parts.length - 1];
+  return last.replace(/^"(.*)"$/, "$1").trim();
+}
 function parseCreateTable(sql, state) {
-  const re = /CREATE\s+TABLE\s+"(\w+)"\s*\(([\s\S]*?)\);/gi;
+  const re = new RegExp(
+    `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s*\\(([\\s\\S]*?)\\);`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const tableName = m[1];
+    const tableName = bareName(m[1]);
     const body = m[2];
     const columns = /* @__PURE__ */ new Map();
     let primaryCol = null;
-    for (const line of body.split("\n")) {
-      const trimmed = line.trim().replace(/,\s*$/, "");
+    const inlineFks = [];
+    const lines = splitTopLevelCommas(body);
+    for (const raw of lines) {
+      const trimmed = raw.trim().replace(/,\s*$/, "");
       if (!trimmed || trimmed.startsWith("--")) continue;
-      const pkMatch = trimmed.match(/CONSTRAINT\s+"[^"]+"\s+PRIMARY\s+KEY\s*\("(\w+)"\)/i);
-      if (pkMatch) {
-        primaryCol = pkMatch[1];
+      const namedPk = trimmed.match(new RegExp(`^CONSTRAINT\\s+${ID}\\s+PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (namedPk) {
+        primaryCol = bareName(namedPk[1]);
+        continue;
+      }
+      const tablePk = trimmed.match(new RegExp(`^PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (tablePk) {
+        primaryCol = bareName(tablePk[1]);
+        continue;
+      }
+      if (/^UNIQUE\s*\(/i.test(trimmed)) continue;
+      const namedFk = trimmed.match(new RegExp(
+        `^CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (namedFk) {
+        inlineFks.push({
+          constraintName: bareName(namedFk[1]),
+          sourceTable: tableName,
+          sourceColumn: bareName(namedFk[2]),
+          targetTable: bareName(namedFk[3]),
+          targetColumn: bareName(namedFk[4]),
+          onDelete: namedFk[5] ?? null
+        });
         continue;
       }
-      if (/^\s*CONSTRAINT\s/i.test(trimmed)) continue;
-      const colMatch = trimmed.match(/^"(\w+)"\s+(.+)/);
+      const bareFk = trimmed.match(new RegExp(
+        `^FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (bareFk) {
+        inlineFks.push({
+          constraintName: `${tableName}_${bareName(bareFk[1])}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: bareName(bareFk[1]),
+          targetTable: bareName(bareFk[2]),
+          targetColumn: bareName(bareFk[3]),
+          onDelete: bareFk[4] ?? null
+        });
+        continue;
+      }
+      if (/^CONSTRAINT\s/i.test(trimmed)) continue;
+      const colMatch = trimmed.match(new RegExp(`^(${ID})\\s+(.+)`, "i"));
       if (!colMatch) continue;
-      const colName = colMatch[1];
+      const colName = bareName(colMatch[1]);
       let rest = colMatch[2];
+      const inlineRefMatch = rest.match(new RegExp(
+        `\\bREFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (inlineRefMatch) {
+        inlineFks.push({
+          constraintName: `${tableName}_${colName}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: colName,
+          targetTable: bareName(inlineRefMatch[1]),
+          targetColumn: bareName(inlineRefMatch[2]),
+          onDelete: inlineRefMatch[3] ?? null
+        });
+        rest = rest.replace(inlineRefMatch[0], "").trim();
+      }
       const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
+      const isPrimaryKey = /\bPRIMARY\s+KEY\b/i.test(rest);
+      const isUnique = /\bUNIQUE\b/i.test(rest);
       const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)(?:\s*,?\s*$)/i);
       const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
-      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
+      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bPRIMARY\s+KEY\b/gi, "").replace(/\bUNIQUE\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
       columns.set(colName, {
         name: colName,
         type: colType,
-        nullable: !isNotNull,
-        primary: false,
-        unique: false,
+        nullable: !isNotNull && !isPrimaryKey,
+        primary: isPrimaryKey,
+        unique: isUnique,
         default: defaultVal
       });
+      if (isPrimaryKey) primaryCol = colName;
     }
     if (primaryCol && columns.has(primaryCol)) {
       columns.get(primaryCol).primary = true;
     }
     state.tables.set(tableName, { name: tableName, columns });
+    state.fks.push(...inlineFks);
   }
 }
+function splitTopLevelCommas(body) {
+  const out = [];
+  let depth = 0;
+  let buf = "";
+  let inString = null;
+  for (const ch of body) {
+    if (inString) {
+      buf += ch;
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      inString = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      out.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim()) out.push(buf);
+  return out;
+}
 function parseCreateEnum(sql, state) {
-  const re = /CREATE\s+TYPE\s+"(\w+)"\s+AS\s+ENUM\s*\(([^)]+)\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+TYPE\\s+(${QID})\\s+AS\\s+ENUM\\s*\\(([^)]+)\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const enumName = m[1];
+    const enumName = bareName(m[1]);
     const valuesStr = m[2];
     const values = new Set(
       valuesStr.split(",").map((v) => v.trim().replace(/^'(.*)'$/, "$1")).filter(Boolean)
@@ -1554,11 +1845,14 @@ function parseCreateEnum(sql, state) {
   }
 }
 function parseAlterTable(sql, state) {
-  const addColRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+COLUMN\s+"(\w+)"\s+(.+?);/gi;
+  const addColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+COLUMN\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s+(.+?);`,
+    "gi"
+  );
   let m;
   while ((m = addColRe.exec(sql)) !== null) {
-    const tableName = m[1];
-    const colName = m[2];
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
     let rest = m[3];
     const table = state.tables.get(tableName);
     if (!table) continue;
@@ -1575,63 +1869,91 @@ function parseAlterTable(sql, state) {
       default: defaultVal
     });
   }
-  const dropColRe = /ALTER\s+TABLE\s+"(\w+)"\s+DROP\s+COLUMN\s+"(\w+)"/gi;
+  const dropColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+DROP\\s+COLUMN\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   while ((m = dropColRe.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    if (table) table.columns.delete(m[2]);
+    const table = state.tables.get(bareName(m[1]));
+    if (table) table.columns.delete(bareName(m[2]));
   }
-  const fkRe = /ALTER\s+TABLE\s+"(\w+)"\s+ADD\s+CONSTRAINT\s+"([^"]+)"\s+FOREIGN\s+KEY\s*\("(\w+)"\)\s+REFERENCES\s+"(\w+)"\("(\w+)"\)(?:\s+ON\s+DELETE\s+(\w+(?:\s+\w+)?))?/gi;
+  const fkRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+    "gi"
+  );
   while ((m = fkRe.exec(sql)) !== null) {
     state.fks.push({
-      constraintName: m[2],
-      sourceTable: m[1],
-      sourceColumn: m[3],
-      targetTable: m[4],
-      targetColumn: m[5],
+      constraintName: bareName(m[2]),
+      sourceTable: bareName(m[1]),
+      sourceColumn: bareName(m[3]),
+      targetTable: bareName(m[4]),
+      targetColumn: bareName(m[5]),
       onDelete: m[6] ?? null
     });
   }
 }
 function parseAlterEnum(sql, state) {
-  const re = /ALTER\s+TYPE\s+"(\w+)"\s+ADD\s+VALUE\s+'([^']+)'/gi;
+  const re = new RegExp(
+    `ALTER\\s+TYPE\\s+(${QID})\\s+ADD\\s+VALUE\\s+'([^']+)'`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const en = state.enums.get(m[1]);
+    const en = state.enums.get(bareName(m[1]));
     if (en) en.values.add(m[2]);
   }
 }
 function parseDropTable(sql, state) {
-  const re = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?"(\w+)"/gi;
+  const re = new RegExp(
+    `DROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    state.tables.delete(m[1]);
-    state.fks = state.fks.filter((fk) => fk.sourceTable !== m[1] && fk.targetTable !== m[1]);
+    const dropped = bareName(m[1]);
+    state.tables.delete(dropped);
+    state.fks = state.fks.filter((fk) => fk.sourceTable !== dropped && fk.targetTable !== dropped);
   }
 }
 function parseUniqueIndex(sql, state) {
-  const re = /CREATE\s+UNIQUE\s+INDEX\s+"[^"]+"\s+ON\s+"(\w+)"\("(\w+)"\)/gi;
+  const re = new RegExp(
+    `CREATE\\s+UNIQUE\\s+INDEX\\s+(?:(?:IF\\s+NOT\\s+EXISTS\\s+)?(?:${ID}\\s+)?)?ON\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)`,
+    "gi"
+  );
   let m;
   while ((m = re.exec(sql)) !== null) {
-    const table = state.tables.get(m[1]);
-    const col = table?.columns.get(m[2]);
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
+    const table = state.tables.get(tableName);
+    const col = table?.columns.get(colName);
     if (col) col.unique = true;
-    if (!state.uniqueIndexes.has(m[1])) state.uniqueIndexes.set(m[1], /* @__PURE__ */ new Set());
-    state.uniqueIndexes.get(m[1]).add(m[2]);
+    if (!state.uniqueIndexes.has(tableName)) state.uniqueIndexes.set(tableName, /* @__PURE__ */ new Set());
+    state.uniqueIndexes.get(tableName).add(colName);
+  }
+}
+function discoverMigrationFiles(migrationsDir) {
+  if (!(0, import_node_fs7.existsSync)(migrationsDir)) return [];
+  const out = [];
+  const entries = (0, import_node_fs7.readdirSync)(migrationsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const sqlPath = (0, import_node_path6.join)(migrationsDir, entry.name, "migration.sql");
+      if ((0, import_node_fs7.existsSync)(sqlPath)) out.push(sqlPath);
+    } else if (entry.isFile() && entry.name.endsWith(".sql")) {
+      out.push((0, import_node_path6.join)(migrationsDir, entry.name));
+    }
   }
+  return out;
 }
-function parseMigrations(rootDir) {
-  const migrationsDir = (0, import_node_path7.join)(rootDir, "prisma", "migrations");
+function parseMigrations(migrationsDir) {
   const state = {
     tables: /* @__PURE__ */ new Map(),
     enums: /* @__PURE__ */ new Map(),
     fks: [],
     uniqueIndexes: /* @__PURE__ */ new Map()
   };
-  if (!(0, import_node_fs7.existsSync)(migrationsDir)) return state;
-  const dirs = (0, import_node_fs7.readdirSync)(migrationsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
-  for (const dir of dirs) {
-    const sqlPath = (0, import_node_path7.join)(migrationsDir, dir, "migration.sql");
-    if (!(0, import_node_fs7.existsSync)(sqlPath)) continue;
+  if (!migrationsDir) return state;
+  for (const sqlPath of discoverMigrationFiles(migrationsDir)) {
     const sql = (0, import_node_fs7.readFileSync)(sqlPath, "utf-8");
     parseCreateEnum(sql, state);
     parseCreateTable(sql, state);
@@ -1642,9 +1964,8 @@ function parseMigrations(rootDir) {
   }
   return state;
 }
-function loadPrismaState(rootDir) {
-  const schemaPath = (0, import_node_path7.join)(rootDir, "prisma", "schema.prisma");
-  if (!(0, import_node_fs7.existsSync)(schemaPath)) return null;
+function loadPrismaState(schemaPath) {
+  if (!schemaPath || !(0, import_node_fs7.existsSync)(schemaPath)) return null;
   const content = (0, import_node_fs7.readFileSync)(schemaPath, "utf-8");
   const tables = /* @__PURE__ */ new Map();
   const enums = /* @__PURE__ */ new Map();
@@ -1809,14 +2130,28 @@ function verify(sqlState, prisma) {
   }
   return { contradictions, flaggedEdges };
 }
+function migrationsDirFor(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (!paths) return null;
+  if (paths.dbConfig.kind === "prisma" || paths.dbConfig.kind === "sql-migrations") {
+    return paths.dbConfig.migrationsDir;
+  }
+  return null;
+}
+function schemaPathFor(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (!paths) return null;
+  return paths.dbConfig.kind === "prisma" ? paths.dbConfig.schemaPath : null;
+}
 function detect3(rootDir) {
-  const migrationsDir = (0, import_node_path7.join)(rootDir, "prisma", "migrations");
-  if (!(0, import_node_fs7.existsSync)(migrationsDir)) return false;
-  return (0, import_node_fs7.readdirSync)(migrationsDir, { withFileTypes: true }).some((d) => d.isDirectory() && (0, import_node_fs7.existsSync)((0, import_node_path7.join)(migrationsDir, d.name, "migration.sql")));
+  const dir = migrationsDirFor(rootDir);
+  if (!dir) return false;
+  return discoverMigrationFiles(dir).length > 0;
 }
 function generate3(rootDir) {
-  const sqlState = parseMigrations(rootDir);
-  const prisma = loadPrismaState(rootDir);
+  const migrationsDir = migrationsDirFor(rootDir);
+  const sqlState = parseMigrations(migrationsDir);
+  const prisma = loadPrismaState(schemaPathFor(rootDir));
   const prismaTableIds = prisma ? new Set(prisma.tables.keys()) : /* @__PURE__ */ new Set();
   const prismaEnumIds = prisma ? new Set(prisma.enums.keys()) : /* @__PURE__ */ new Set();
   const nodes = [];
@@ -1862,7 +2197,7 @@ function generate3(rootDir) {
     metadata: {
       generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
       scope: "sql-migrations",
-      source: "prisma/migrations/",
+      source: migrationsDir ?? "none",
       layer: "db",
       sql_tables: sqlState.tables.size,
       sql_enums: sqlState.enums.size,
@@ -2101,31 +2436,31 @@ var fetchResolverParser = {
 
 // src/server/graph/parsers/crosslayer/api-annotations.ts
 var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_path7 = require("node:path");
 var API_ANNOTATION_RE = /@api\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S+)/g;
 function walk2(dir, exts) {
   if (!(0, import_node_fs8.existsSync)(dir)) return [];
   const results = [];
   for (const entry of (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const full = (0, import_node_path8.join)(dir, entry.name);
+    const full = (0, import_node_path7.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk2(full, exts));
-    } else if (exts.includes((0, import_node_path8.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path7.extname)(entry.name))) {
       results.push(full);
     }
   }
   return results;
 }
 function toNodeId2(srcDir, absPath) {
-  return (0, import_node_path8.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path7.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
 var apiAnnotationsParser = {
   id: "api-annotations",
   layer: "crosslayer",
   concern: "api-binding",
   detect(rootDir) {
-    return (0, import_node_fs8.existsSync)((0, import_node_path8.join)(rootDir, "src"));
+    return (0, import_node_fs8.existsSync)((0, import_node_path7.join)(rootDir, "src"));
   },
   generate(rootDir, layerOutputs) {
     const apiOutput = layerOutputs.get("api");
@@ -2136,7 +2471,7 @@ var apiAnnotationsParser = {
     const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
     const apiRoutes = loadApiRoutesFromOutput(apiOutput);
     const apiPathMap = buildApiPathMap(apiRoutes);
-    const srcDir = (0, import_node_path8.join)(rootDir, "src");
+    const srcDir = (0, import_node_path7.join)(rootDir, "src");
     const files = walk2(srcDir, [".ts", ".tsx"]);
     const crossRefs = [];
     const flaggedEdges = [];
@@ -2187,7 +2522,7 @@ var apiAnnotationsParser = {
 
 // src/server/graph/parsers/crosslayer/url-literal-scanner.ts
 var import_node_fs9 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_path8 = require("node:path");
 init_config();
 var URL_LITERAL_RE = /['"`](\/api\/[^'"`\s]+?)['"`]/g;
 function walk3(dir, exts) {
@@ -2195,17 +2530,17 @@ function walk3(dir, exts) {
   const results = [];
   for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const full = (0, import_node_path9.join)(dir, entry.name);
+    const full = (0, import_node_path8.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk3(full, exts));
-    } else if (exts.includes((0, import_node_path9.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path8.extname)(entry.name))) {
       results.push(full);
     }
   }
   return results;
 }
 function toNodeId3(srcDir, absPath) {
-  return (0, import_node_path9.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path8.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
 var urlLiteralScannerParser = {
   id: "url-literal-scanner",
@@ -2226,7 +2561,7 @@ var urlLiteralScannerParser = {
     const apiPathMap = buildApiPathMap(apiRoutes);
     const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
     const srcDir = paths.srcDir;
-    const clientDir = (0, import_node_path9.join)(srcDir, "client");
+    const clientDir = (0, import_node_path8.join)(srcDir, "client");
     const files = [
       ...walk3(clientDir, [".ts", ".tsx"]),
       ...walk3(paths.appDir, [".ts", ".tsx"])
@@ -2268,7 +2603,7 @@ var urlLiteralScannerParser = {
 
 // src/server/graph/parsers/static/static-values.ts
 var import_node_fs10 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_path9 = require("node:path");
 var parseCode = null;
 function tryLoadTreeSitter() {
   if (parseCode) return true;
@@ -2301,8 +2636,8 @@ function extractEnumValues(rootDir) {
   const nodes = [];
   const edges = [];
   const schemaPaths = [
-    (0, import_node_path10.join)(rootDir, "prisma", "schema.prisma"),
-    (0, import_node_path10.join)(rootDir, "prisma", "schema")
+    (0, import_node_path9.join)(rootDir, "prisma", "schema.prisma"),
+    (0, import_node_path9.join)(rootDir, "prisma", "schema")
   ];
   let content = "";
   for (const p of schemaPaths) {
@@ -2313,7 +2648,7 @@ function extractEnumValues(rootDir) {
           content = (0, import_node_fs10.readFileSync)(p, "utf-8");
         } else if (stat.isDirectory()) {
           const files = (0, import_node_fs10.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
-          content = files.map((f) => (0, import_node_fs10.readFileSync)((0, import_node_path10.join)(p, f), "utf-8")).join("\n");
+          content = files.map((f) => (0, import_node_fs10.readFileSync)((0, import_node_path9.join)(p, f), "utf-8")).join("\n");
         }
       } catch {
         continue;
@@ -2469,14 +2804,14 @@ function extractSeedData(rootDir) {
   const nodes = [];
   const edges = [];
   const seedFiles = [
-    (0, import_node_path10.join)(rootDir, "prisma", "seed.ts"),
-    (0, import_node_path10.join)(rootDir, "prisma", "seed.js"),
-    (0, import_node_path10.join)(rootDir, "src", "server", "lib", "system-tags.ts")
+    (0, import_node_path9.join)(rootDir, "prisma", "seed.ts"),
+    (0, import_node_path9.join)(rootDir, "prisma", "seed.js"),
+    (0, import_node_path9.join)(rootDir, "src", "server", "lib", "system-tags.ts")
   ].filter(import_node_fs10.existsSync);
   const useTreeSitter = tryLoadTreeSitter();
   for (const filePath of seedFiles) {
     const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path10.relative)(rootDir, filePath);
+    const relPath = (0, import_node_path9.relative)(rootDir, filePath);
     const seeded = detectSeededArrays(content, relPath);
     let astRoot = null;
     if (useTreeSitter && parseCode) {
@@ -2574,7 +2909,7 @@ function walkDir(dir, exts) {
   const results = [];
   for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
-    const full = (0, import_node_path10.join)(dir, entry.name);
+    const full = (0, import_node_path9.join)(dir, entry.name);
     if (entry.isDirectory()) results.push(...walkDir(full, exts));
     else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(full);
   }
@@ -2582,11 +2917,11 @@ function walkDir(dir, exts) {
 }
 function extractConstants(rootDir) {
   const nodes = [];
-  const srcDir = (0, import_node_path10.join)(rootDir, "src");
+  const srcDir = (0, import_node_path9.join)(rootDir, "src");
   if (!(0, import_node_fs10.existsSync)(srcDir)) return { nodes };
   for (const filePath of walkDir(srcDir, [".ts", ".tsx"])) {
     const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path10.relative)(rootDir, filePath);
+    const relPath = (0, import_node_path9.relative)(rootDir, filePath);
     const constArrayRe = /export\s+const\s+([A-Z][A-Z_0-9]+)\s*(?::[^=]+)?\s*=\s*\[/g;
     let cm;
     while ((cm = constArrayRe.exec(content)) !== null) {
@@ -2619,7 +2954,7 @@ function extractConstants(rootDir) {
   return { nodes };
 }
 function detect4(rootDir) {
-  return (0, import_node_fs10.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs10.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "seed.ts"));
+  return (0, import_node_fs10.existsSync)((0, import_node_path9.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs10.existsSync)((0, import_node_path9.join)(rootDir, "prisma", "seed.ts"));
 }
 function generate4(rootDir) {
   const enumResult = extractEnumValues(rootDir);
@@ -2695,7 +3030,7 @@ var staticValuesParser = {
 
 // src/server/graph/parsers/crosslayer/static-ref-scanner.ts
 var import_node_fs11 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_path10 = require("node:path");
 init_config();
 var MIN_VALUE_LENGTH = 4;
 var SKIP_VALUES = /* @__PURE__ */ new Set([
@@ -2839,11 +3174,11 @@ var staticRefScannerParser = {
     if (!paths) return { cross_refs: [], flagged_edges: [], warnings: [] };
     const srcDir = paths.srcDir;
     const files = [
-      ...walkWithIgnore((0, import_node_path11.join)(srcDir, "client"), [".ts", ".tsx"]),
+      ...walkWithIgnore((0, import_node_path10.join)(srcDir, "client"), [".ts", ".tsx"]),
       ...walkWithIgnore(paths.appDir, [".ts", ".tsx"]),
-      ...walkWithIgnore((0, import_node_path11.join)(srcDir, "server"), [".ts", ".tsx"]),
-      ...walkWithIgnore((0, import_node_path11.join)(srcDir, "lib"), [".ts", ".tsx"]),
-      ...walkWithIgnore((0, import_node_path11.join)(srcDir, "config"), [".ts", ".tsx"])
+      ...walkWithIgnore((0, import_node_path10.join)(srcDir, "server"), [".ts", ".tsx"]),
+      ...walkWithIgnore((0, import_node_path10.join)(srcDir, "lib"), [".ts", ".tsx"]),
+      ...walkWithIgnore((0, import_node_path10.join)(srcDir, "config"), [".ts", ".tsx"])
     ];
     const uiOutput = layerOutputs.get("ui");
     const apiOutput = layerOutputs.get("api");
@@ -2861,7 +3196,7 @@ var staticRefScannerParser = {
     const seen = /* @__PURE__ */ new Set();
     let filesScanned = 0;
     for (const absPath of files) {
-      const sourceId = (0, import_node_path11.relative)(srcDir, absPath).replace(/\\/g, "/");
+      const sourceId = (0, import_node_path10.relative)(srcDir, absPath).replace(/\\/g, "/");
       const sourceLayer = uiNodeIds.has(sourceId) ? "ui" : apiNodeIds.has(sourceId) ? "api" : null;
       if (!sourceLayer) continue;
       const content = (0, import_node_fs11.readFileSync)(absPath, "utf-8");
@@ -2980,7 +3315,7 @@ function registerBuiltins(registry, disabled) {
 function loadCustomParsers(registry, config, rootDir, disabled) {
   for (const entry of config.parsers?.custom ?? []) {
     try {
-      const absPath = (0, import_node_path12.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path11.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const parser = "default" in mod ? mod.default : mod;
       if (disabled.has(parser.id)) continue;
@@ -3110,7 +3445,7 @@ function applyCrossLayerResults(uiOutput, results) {
 
 // src/server/graph/core/graph-builder.ts
 function readGraphFromDisk(rootDir, layer) {
-  const filePath = (0, import_node_path13.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
+  const filePath = (0, import_node_path12.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
   if (!(0, import_node_fs12.existsSync)(filePath)) return null;
   try {
     return JSON.parse((0, import_node_fs12.readFileSync)(filePath, "utf-8"));
@@ -3214,11 +3549,11 @@ function generateAll(rootDir) {
 init_config();
 
 // src/server/graph/core/tagger-registry.ts
-var import_node_path15 = require("node:path");
+var import_node_path14 = require("node:path");
 
 // src/server/graph/taggers/module-tagger.ts
 var import_node_fs13 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_path13 = require("node:path");
 function matchGlob(pattern, id) {
   const patParts = pattern.split("/");
   const idParts = id.split("/");
@@ -3251,13 +3586,13 @@ function detectConventionDirs(rootDir, extraConventionDirs = []) {
   const conventionDirs = [...CONVENTION_DIRS_BUILTIN, ...extraConventionDirs];
   const searchDirs = [
     rootDir,
-    (0, import_node_path14.join)(rootDir, "src"),
-    (0, import_node_path14.join)(rootDir, "app"),
-    (0, import_node_path14.join)(rootDir, "lib")
+    (0, import_node_path13.join)(rootDir, "src"),
+    (0, import_node_path13.join)(rootDir, "app"),
+    (0, import_node_path13.join)(rootDir, "lib")
   ];
   for (const base of searchDirs) {
     for (const convention of conventionDirs) {
-      const dir = (0, import_node_path14.join)(base, convention);
+      const dir = (0, import_node_path13.join)(base, convention);
       if (!(0, import_node_fs13.existsSync)(dir)) continue;
       try {
         const stat = (0, import_node_fs13.statSync)(dir);
@@ -3556,7 +3891,7 @@ function loadCustomTaggers(registry, config, rootDir, disabled) {
   for (const entry of config.taggers?.custom ?? []) {
     if (disabled.has(entry.id)) continue;
     try {
-      const absPath = (0, import_node_path15.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path14.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const tagger = "default" in mod ? mod.default : mod;
       const override = config.taggers?.trackUntagged?.[tagger.id];
@@ -3580,12 +3915,12 @@ function createTaggerRegistry(config, rootDir) {
 
 // src/server/graph/core/tag-store.ts
 var import_node_fs14 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_path15 = require("node:path");
 var TAGS_FILENAME = "tags.json";
 var GRAPHS_DIR = ".launchsecure/graphs";
 var tagCache = /* @__PURE__ */ new Map();
 function tagsFilePath(rootDir) {
-  return (0, import_node_path16.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
+  return (0, import_node_path15.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
 }
 function readTagStore(rootDir) {
   const filePath = tagsFilePath(rootDir);
@@ -3606,7 +3941,7 @@ function readTagStore(rootDir) {
 }
 function writeTagStore(rootDir, store) {
   const filePath = tagsFilePath(rootDir);
-  const dir = (0, import_node_path16.dirname)(filePath);
+  const dir = (0, import_node_path15.dirname)(filePath);
   (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
   const cleaned = {};
   for (const [nodeId, tags] of Object.entries(store)) {
@@ -3637,20 +3972,20 @@ function removeTag(rootDir, nodeId, key) {
 init_ts_extractor();
 var GRAPHS_DIR2 = ".launchsecure/graphs";
 function getAvailableLayers(rootDir) {
-  const dir = (0, import_node_path17.join)(rootDir, GRAPHS_DIR2);
+  const dir = (0, import_node_path16.join)(rootDir, GRAPHS_DIR2);
   if (!(0, import_node_fs15.existsSync)(dir)) return [];
   return (0, import_node_fs15.readdirSync)(dir).filter((f) => f.endsWith(".json") && f !== "tags.json").map((f) => f.replace(".json", ""));
 }
 var graphCache = /* @__PURE__ */ new Map();
 var taggedCache = /* @__PURE__ */ new Map();
 function graphsDir(rootDir) {
-  return (0, import_node_path17.join)(rootDir, GRAPHS_DIR2);
+  return (0, import_node_path16.join)(rootDir, GRAPHS_DIR2);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path17.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path16.join)(graphsDir(rootDir), `${layer}.json`);
 }
 function tagsFilePath2(rootDir) {
-  return (0, import_node_path17.join)(graphsDir(rootDir), "tags.json");
+  return (0, import_node_path16.join)(graphsDir(rootDir), "tags.json");
 }
 function getMtimeMs(filePath) {
   if (!(0, import_node_fs15.existsSync)(filePath)) return 0;
@@ -3751,15 +4086,15 @@ async function generateGraph(rootDir, layer) {
 var import_node_child_process = require("node:child_process");
 var import_node_fs16 = require("node:fs");
 var import_node_os = require("node:os");
-var import_node_path18 = require("node:path");
+var import_node_path17 = require("node:path");
 function lockDir(projectRoot) {
   if (projectRoot) {
-    return (0, import_node_path18.join)(projectRoot, ".launchsecure");
+    return (0, import_node_path17.join)(projectRoot, ".launchsecure");
   }
-  return (0, import_node_path18.join)((0, import_node_os.homedir)(), ".launchsecure");
+  return (0, import_node_path17.join)((0, import_node_os.homedir)(), ".launchsecure");
 }
 function lockPath(projectRoot) {
-  return (0, import_node_path18.join)(lockDir(projectRoot), "launch-chart.lock");
+  return (0, import_node_path17.join)(lockDir(projectRoot), "launch-chart.lock");
 }
 var _activeProjectRoot;
 function readLock(projectRoot) {
@@ -3844,9 +4179,9 @@ init_config();
 
 // src/server/graph/core/audit-core.ts
 var import_node_fs17 = require("node:fs");
-var import_node_path19 = require("node:path");
+var import_node_path18 = require("node:path");
 function readGraphFile(rootDir, layer) {
-  const filePath = (0, import_node_path19.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
+  const filePath = (0, import_node_path18.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
   if (!(0, import_node_fs17.existsSync)(filePath)) return null;
   try {
     return JSON.parse((0, import_node_fs17.readFileSync)(filePath, "utf-8"));
@@ -3893,7 +4228,7 @@ function checkUnprotectedRoutes(rootDir) {
   const api = readGraphFile(rootDir, "api");
   const staticGraph = readGraphFile(rootDir, "static");
   if (!api) return buildReport("api", "unprotected_routes", findings);
-  const routePermsPath = (0, import_node_path19.join)(rootDir, "src", "config", "route-permissions.ts");
+  const routePermsPath = (0, import_node_path18.join)(rootDir, "src", "config", "route-permissions.ts");
   let routePermsContent = "";
   if ((0, import_node_fs17.existsSync)(routePermsPath)) {
     routePermsContent = (0, import_node_fs17.readFileSync)(routePermsPath, "utf-8");
@@ -3973,7 +4308,7 @@ function checkUnenforcedPermissions(rootDir) {
   const staticGraph = readGraphFile(rootDir, "static");
   if (!staticGraph) return buildReport("static", "unenforced_permissions", findings);
   const permissions = staticGraph.nodes.filter((n) => n.type === "seed_permission").map((n) => ({ id: n.id, key: n.value, name: n.name }));
-  const routePermsPath = (0, import_node_path19.join)(rootDir, "src", "config", "route-permissions.ts");
+  const routePermsPath = (0, import_node_path18.join)(rootDir, "src", "config", "route-permissions.ts");
   let routePermsContent = "";
   if ((0, import_node_fs17.existsSync)(routePermsPath)) {
     routePermsContent = (0, import_node_fs17.readFileSync)(routePermsPath, "utf-8");
@@ -4006,7 +4341,7 @@ function checkHardcodedValues(rootDir) {
   const seen = /* @__PURE__ */ new Set();
   for (const node of api.nodes) {
     if (node.type !== "endpoint") continue;
-    const filePath = (0, import_node_path19.join)(rootDir, "src", node.id);
+    const filePath = (0, import_node_path18.join)(rootDir, "src", node.id);
     if (!(0, import_node_fs17.existsSync)(filePath)) continue;
     const content = (0, import_node_fs17.readFileSync)(filePath, "utf-8");
     let m;
@@ -4138,16 +4473,16 @@ var MIME_TYPES = {
 function findProjectRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
-    const graphsDir2 = import_node_path20.default.join(dir, ".launchsecure", "graphs");
-    if (import_node_fs18.default.existsSync(import_node_path20.default.join(graphsDir2, "ui.json")) || import_node_fs18.default.existsSync(import_node_path20.default.join(graphsDir2, "api.json")) || import_node_fs18.default.existsSync(import_node_path20.default.join(graphsDir2, "db.json"))) return dir;
-    const parent = import_node_path20.default.dirname(dir);
+    const graphsDir2 = import_node_path19.default.join(dir, ".launchsecure", "graphs");
+    if (import_node_fs18.default.existsSync(import_node_path19.default.join(graphsDir2, "ui.json")) || import_node_fs18.default.existsSync(import_node_path19.default.join(graphsDir2, "api.json")) || import_node_fs18.default.existsSync(import_node_path19.default.join(graphsDir2, "db.json"))) return dir;
+    const parent = import_node_path19.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = startDir;
   for (let i = 0; i < 8; i++) {
-    if (import_node_fs18.default.existsSync(import_node_path20.default.join(dir, ".git"))) return dir;
-    const parent = import_node_path20.default.dirname(dir);
+    if (import_node_fs18.default.existsSync(import_node_path19.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path19.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4156,7 +4491,7 @@ function findProjectRoot(startDir) {
 function resolveRequestRoot(url, monorepoRoot, projects) {
   const projectParam = url.searchParams.get("project");
   if (!projectParam || projects.length === 0) return monorepoRoot;
-  const resolved = import_node_path20.default.resolve(monorepoRoot, projectParam);
+  const resolved = import_node_path19.default.resolve(monorepoRoot, projectParam);
   if (!resolved.startsWith(monorepoRoot)) {
     throw new Error("Project path outside monorepo root");
   }
@@ -4208,14 +4543,14 @@ async function buildMergedGraph(root) {
 }
 function serveStatic(res, filePath) {
   if (!import_node_fs18.default.existsSync(filePath) || !import_node_fs18.default.statSync(filePath).isFile()) return false;
-  const ext = import_node_path20.default.extname(filePath).toLowerCase();
+  const ext = import_node_path19.default.extname(filePath).toLowerCase();
   const mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
   import_node_fs18.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function serveIndex(res, clientDir) {
-  const indexPath = import_node_path20.default.join(clientDir, "index.html");
+  const indexPath = import_node_path19.default.join(clientDir, "index.html");
   if (!import_node_fs18.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'.`);
@@ -4224,14 +4559,14 @@ function serveIndex(res, clientDir) {
   serveStatic(res, indexPath);
 }
 function tryListen(server, port) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve3(port);
+      resolve4(port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -4268,7 +4603,7 @@ async function startChartServer(opts = {}) {
     }
     return { port: existing.port, url: existing.url };
   }
-  const clientDir = opts.clientDir ?? import_node_path20.default.join(__dirname, "..", "chart-client");
+  const clientDir = opts.clientDir ?? import_node_path19.default.join(__dirname, "..", "chart-client");
   const rootConfig = loadConfig(projectRoot);
   const projects = rootConfig.projects ?? [];
   const server = import_node_http.default.createServer((req, res) => {
@@ -4284,11 +4619,11 @@ async function startChartServer(opts = {}) {
       }
       if (req.method === "GET" && url2.pathname === "/api/projects") {
         const projectList = projects.length > 0 ? projects.map((p) => {
-          const absRoot = import_node_path20.default.resolve(projectRoot, p.root);
-          const hasGraphs = import_node_fs18.default.existsSync(import_node_path20.default.join(absRoot, ".launchsecure", "graphs"));
-          const hasNextConfig = import_node_fs18.default.existsSync(import_node_path20.default.join(absRoot, "next.config.ts")) || import_node_fs18.default.existsSync(import_node_path20.default.join(absRoot, "next.config.js")) || import_node_fs18.default.existsSync(import_node_path20.default.join(absRoot, "next.config.mjs"));
+          const absRoot = import_node_path19.default.resolve(projectRoot, p.root);
+          const hasGraphs = import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, ".launchsecure", "graphs"));
+          const hasNextConfig = import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, "next.config.ts")) || import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, "next.config.js")) || import_node_fs18.default.existsSync(import_node_path19.default.join(absRoot, "next.config.mjs"));
           return { name: p.name, root: p.root, hasGraphs, hasNextConfig };
-        }) : [{ name: import_node_path20.default.basename(projectRoot), root: ".", hasGraphs: import_node_fs18.default.existsSync(import_node_path20.default.join(projectRoot, ".launchsecure", "graphs")), hasNextConfig: true }];
+        }) : [{ name: import_node_path19.default.basename(projectRoot), root: ".", hasGraphs: import_node_fs18.default.existsSync(import_node_path19.default.join(projectRoot, ".launchsecure", "graphs")), hasNextConfig: true }];
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ projects: projectList, monorepoRoot: projectRoot }));
         return;
@@ -4334,18 +4669,18 @@ async function startChartServer(opts = {}) {
       }
       if (req.method === "GET" && url2.pathname === "/api/file-content") {
         const relPath = url2.searchParams.get("path");
-        if (!relPath || relPath.includes("..") || import_node_path20.default.isAbsolute(relPath)) {
+        if (!relPath || relPath.includes("..") || import_node_path19.default.isAbsolute(relPath)) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "Invalid path" }));
           return;
         }
-        const filePath = import_node_path20.default.join(reqRoot, relPath);
+        const filePath = import_node_path19.default.join(reqRoot, relPath);
         if (!filePath.startsWith(reqRoot) || !import_node_fs18.default.existsSync(filePath) || !import_node_fs18.default.statSync(filePath).isFile()) {
           res.writeHead(404, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "File not found" }));
           return;
         }
-        const ext = import_node_path20.default.extname(filePath).toLowerCase();
+        const ext = import_node_path19.default.extname(filePath).toLowerCase();
         const langMap = { ".ts": "typescript", ".tsx": "tsx", ".js": "javascript", ".jsx": "jsx", ".prisma": "prisma", ".json": "json", ".css": "css" };
         const content = import_node_fs18.default.readFileSync(filePath, "utf-8");
         res.writeHead(200, { "Content-Type": "application/json" });
@@ -4389,7 +4724,7 @@ async function startChartServer(opts = {}) {
         req.on("end", () => {
           try {
             const newConfig = JSON.parse(body);
-            const configPath = import_node_path20.default.join(reqRoot, ".launchchart.json");
+            const configPath = import_node_path19.default.join(reqRoot, ".launchchart.json");
             import_node_fs18.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ ok: true }));
@@ -4423,7 +4758,7 @@ async function startChartServer(opts = {}) {
             const taggerConfig = JSON.parse(body);
             const config2 = loadConfig(reqRoot);
             config2.taggers = taggerConfig;
-            const configPath = import_node_path20.default.join(reqRoot, ".launchchart.json");
+            const configPath = import_node_path19.default.join(reqRoot, ".launchchart.json");
             import_node_fs18.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ ok: true }));
@@ -4491,16 +4826,23 @@ async function startChartServer(opts = {}) {
         const paths = resolveProjectPaths(reqRoot, config2);
         const overrides = {
           appDir: !!config2.paths?.appDir,
-          dbDir: !!config2.paths?.dbDir
+          dbDir: !!config2.paths?.dbDir,
+          srcRoots: !!(config2.paths?.srcRoots && config2.paths.srcRoots.length > 0)
         };
+        const relFromRoot = (abs) => import_node_path19.default.relative(reqRoot, abs) || ".";
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({
           projectRoot: reqRoot,
           detected: paths ? {
-            srcDir: import_node_path20.default.relative(reqRoot, paths.srcDir) || ".",
-            appDir: import_node_path20.default.relative(reqRoot, paths.appDir),
-            apiDir: import_node_path20.default.relative(reqRoot, paths.apiDir),
-            dbDir: paths.dbDir ? import_node_path20.default.relative(reqRoot, paths.dbDir) : null
+            srcDir: relFromRoot(paths.srcDir),
+            appDir: relFromRoot(paths.appDir),
+            apiDir: relFromRoot(paths.apiDir),
+            dbDir: paths.dbDir ? relFromRoot(paths.dbDir) : null,
+            dbKind: paths.dbConfig.kind,
+            dbSchemaPath: paths.dbConfig.schemaPath ? relFromRoot(paths.dbConfig.schemaPath) : null,
+            dbMigrationsDir: paths.dbConfig.migrationsDir ? relFromRoot(paths.dbConfig.migrationsDir) : null,
+            srcRoots: paths.srcRoots.map(relFromRoot),
+            conventionFiles: paths.conventionFiles.map(relFromRoot)
           } : null,
           overrides,
           isOverride: overrides.appDir
@@ -4509,8 +4851,8 @@ async function startChartServer(opts = {}) {
       }
       if (req.method === "GET" && url2.pathname === "/api/browse-dir") {
         const browsePath = url2.searchParams.get("path") || projectRoot;
-        const abs = import_node_path20.default.resolve(browsePath);
-        const twoUp = import_node_path20.default.resolve(projectRoot, "..", "..");
+        const abs = import_node_path19.default.resolve(browsePath);
+        const twoUp = import_node_path19.default.resolve(projectRoot, "..", "..");
         if (!abs.startsWith(twoUp)) {
           res.writeHead(403, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ ok: false, error: "Path outside allowed range" }));
@@ -4519,9 +4861,9 @@ async function startChartServer(opts = {}) {
         try {
           const entries = import_node_fs18.default.readdirSync(abs, { withFileTypes: true });
           const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "dist" && e.name !== ".next").map((e) => e.name).sort();
-          const parent = abs !== twoUp ? import_node_path20.default.dirname(abs) : null;
+          const parent = abs !== twoUp ? import_node_path19.default.dirname(abs) : null;
           res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ current: abs, parent, dirs, relative: import_node_path20.default.relative(projectRoot, abs) || "." }));
+          res.end(JSON.stringify({ current: abs, parent, dirs, relative: import_node_path19.default.relative(projectRoot, abs) || "." }));
         } catch (err) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ ok: false, error: String(err) }));
@@ -4547,7 +4889,7 @@ async function startChartServer(opts = {}) {
             const { projects: newProjects } = JSON.parse(body);
             const config2 = loadConfig(projectRoot);
             config2.projects = newProjects.length > 0 ? newProjects : void 0;
-            const configPath = import_node_path20.default.join(projectRoot, ".launchchart.json");
+            const configPath = import_node_path19.default.join(projectRoot, ".launchchart.json");
             import_node_fs18.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
             projects.length = 0;
             if (config2.projects) projects.push(...config2.projects);
@@ -4561,7 +4903,7 @@ async function startChartServer(opts = {}) {
         return;
       }
       if (url2.pathname !== "/") {
-        const staticPath = import_node_path20.default.join(clientDir, url2.pathname);
+        const staticPath = import_node_path19.default.join(clientDir, url2.pathname);
         if (serveStatic(res, staticPath)) return;
       }
       serveIndex(res, clientDir);