@launchsecure/launch-kit 0.0.16 → 0.0.18

package/dist/server/chart-serve.js

@@ -90,15 +90,15 @@ function getQuery(name) {
   ensureInit();
   const cached = queryCache.get(name);
   if (cached) return cached;
-  const scmPath = (0, import_node_path3.join)(queriesDir, `${name}.scm`);
-  const scm = (0, import_node_fs3.readFileSync)(scmPath, "utf-8");
+  const scmPath = (0, import_node_path4.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs4.readFileSync)(scmPath, "utf-8");
   const query = tsxLanguage.query(scm);
   queryCache.set(name, query);
   return query;
 }
 function parseSource(absPath) {
   ensureInit();
-  const content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
+  const content = (0, import_node_fs4.readFileSync)(absPath, "utf-8");
   return parserInstance.parse(content);
 }
 function parseCodeTS(code) {
@@ -563,17 +563,17 @@ function extractDeep(absPath) {
   }
   return { elements, stateVars, conditions, variables, responses, params };
 }
-var import_node_fs3, import_node_path3, tsxLanguage, parserInstance, initPromise, initialized, queriesDir, queryCache, PRISMA_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods;
+var import_node_fs4, import_node_path4, tsxLanguage, parserInstance, initPromise, initialized, queriesDir, queryCache, PRISMA_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods;
 var init_ts_extractor = __esm({
   "src/server/graph/core/ts-extractor.ts"() {
     "use strict";
-    import_node_fs3 = require("node:fs");
-    import_node_path3 = require("node:path");
+    import_node_fs4 = require("node:fs");
+    import_node_path4 = require("node:path");
     initialized = false;
     queriesDir = (() => {
-      const srcPath = (0, import_node_path3.join)((0, import_node_path3.dirname)(__filename), "..", "queries");
+      const srcPath = (0, import_node_path4.join)((0, import_node_path4.dirname)(__filename), "..", "queries");
       if (require("fs").existsSync(srcPath)) return srcPath;
-      return (0, import_node_path3.join)((0, import_node_path3.dirname)(__filename), "graph", "queries");
+      return (0, import_node_path4.join)((0, import_node_path4.dirname)(__filename), "graph", "queries");
     })();
     queryCache = /* @__PURE__ */ new Map();
     PRISMA_MUTATION_METHODS_BUILTIN = [
@@ -601,24 +601,24 @@ __export(chart_serve_exports, {
 });
 module.exports = __toCommonJS(chart_serve_exports);
 var import_node_http = __toESM(require("node:http"));
-var import_node_fs17 = __toESM(require("node:fs"));
-var import_node_path19 = __toESM(require("node:path"));
+var import_node_fs18 = __toESM(require("node:fs"));
+var import_node_path20 = __toESM(require("node:path"));
 
 // src/server/graph/index.ts
-var import_node_fs14 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path17 = require("node:path");
 
 // src/server/graph/core/graph-builder.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path13 = require("node:path");
 init_config();
 
 // src/server/graph/core/parser-registry.ts
-var import_node_path11 = require("node:path");
+var import_node_path12 = require("node:path");
 
 // src/server/graph/parsers/ts/typescript-project.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
 init_config();
 
 // src/server/graph/core/resolve-paths.ts
@@ -648,6 +648,50 @@ function resolveProjectPaths(rootDir, config) {
   return null;
 }
 
+// src/server/graph/core/walk.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".launchsecure",
+  ".claude",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".vercel",
+  "coverage"
+]);
+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, opts = {}) {
+  const results = [];
+  if (!(0, import_node_fs3.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 })) {
+    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));
+    }
+  }
+  return results;
+}
+
 // src/server/graph/parsers/ts/typescript-project.ts
 init_ts_extractor();
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
@@ -664,48 +708,22 @@ var CLASSIFICATION_TO_LAYER = {
   "mcp-tool": "ui",
   external: "ui"
 };
-function walk(dir, exts) {
-  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(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path4.extname)(entry.name))) {
-      results.push(full);
-    }
-  }
-  return results;
-}
-function walkWithIgnore(dir, exts, ignoreDirs) {
-  const results = [];
-  if (!(0, import_node_fs4.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
-      if (ignoreDirs.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path4.join)(dir, entry.name), exts, ignoreDirs));
-    } else if (exts.includes((0, import_node_path4.extname)(entry.name))) {
-      results.push((0, import_node_path4.join)(dir, entry.name));
-    }
-  }
-  return results;
-}
 function toNodeId(srcDir, absPath) {
-  return (0, import_node_path4.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path5.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
 function resolveImport(srcDir, specifier) {
   if (!specifier.startsWith("@/")) return null;
   const rel = specifier.slice(2);
-  const base = (0, import_node_path4.join)(srcDir, rel);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path4.join)(base, "index.ts"), (0, import_node_path4.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs4.existsSync)(c) && (0, import_node_fs4.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path5.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path5.join)(base, "index.ts"), (0, import_node_path5.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs5.existsSync)(c) && (0, import_node_fs5.statSync)(c).isFile()) return c;
   }
   return null;
 }
 function resolveRelativeImport(fromFile, specifier) {
-  const base = (0, import_node_path4.join)((0, import_node_path4.dirname)(fromFile), specifier);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path4.join)(base, "index.ts"), (0, import_node_path4.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs4.existsSync)(c) && (0, import_node_fs4.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path5.join)((0, import_node_path5.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path5.join)(base, "index.ts"), (0, import_node_path5.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs5.existsSync)(c) && (0, import_node_fs5.statSync)(c).isFile()) return c;
   }
   return null;
 }
@@ -726,7 +744,7 @@ function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
     const resolved = resolveRelativeImport(barrelAbsPath, re.from);
     if (!resolved) continue;
     if (re.isWildcard) {
-      const targetBn = (0, import_node_path4.basename)(resolved);
+      const targetBn = (0, import_node_path5.basename)(resolved);
       const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
       if (targetIsBarrel) {
         const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
@@ -753,12 +771,12 @@ function buildAllBarrelMaps(srcDir, parsedByPath) {
   const barrels = /* @__PURE__ */ new Map();
   const memo = /* @__PURE__ */ new Map();
   for (const [absPath, parsed] of parsedByPath) {
-    const bn = (0, import_node_path4.basename)(absPath);
+    const bn = (0, import_node_path5.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_path4.relative)(srcDir, (0, import_node_path4.dirname)(absPath)).replace(/\\/g, "/");
+      const barrelId = (0, import_node_path5.relative)(srcDir, (0, import_node_path5.dirname)(absPath)).replace(/\\/g, "/");
       barrels.set(barrelId, map);
     }
   }
@@ -779,10 +797,10 @@ function extractRoute(id) {
   return route || "/";
 }
 function nameFromFilename(absPath) {
-  return (0, import_node_path4.basename)(absPath, (0, import_node_path4.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+  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_path4.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
+  let route = "/" + (0, import_node_path5.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
   route = route.replace(/\[([^\]]+)\]/g, ":$1");
   route = route.replace(/\/+/g, "/");
   if (route === "/") return "/api";
@@ -966,12 +984,9 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps,
   }
   return { edges, flagged };
 }
-function hasNextConfig(rootDir) {
-  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "next.config.ts")) || (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "next.config.js")) || (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "next.config.mjs"));
-}
 function detect(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  return paths !== null && hasNextConfig(rootDir);
+  return paths !== null;
 }
 function generate(rootDir) {
   const config = loadConfig(rootDir);
@@ -979,10 +994,10 @@ function generate(rootDir) {
   const srcDir = paths.srcDir;
   const apiDir = paths.apiDir;
   const appFiles = walk(paths.appDir, [".tsx", ".ts"]);
-  const clientFiles = walk((0, import_node_path4.join)(srcDir, "client"), [".tsx", ".ts"]);
-  const serverFiles = walk((0, import_node_path4.join)(srcDir, "server"), [".ts", ".tsx"]);
-  const libFiles = walk((0, import_node_path4.join)(srcDir, "lib"), [".ts", ".tsx"]);
-  const configFiles = walk((0, import_node_path4.join)(srcDir, "config"), [".ts", ".tsx"]);
+  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 parsedByPath = /* @__PURE__ */ new Map();
   for (const absPath of allDiscovered) {
@@ -993,7 +1008,7 @@ function generate(rootDir) {
   const apiNodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const routeToNodeId = /* @__PURE__ */ new Map();
-  const fileSet = allDiscovered.filter((f) => !(0, import_node_path4.basename)(f).startsWith("index."));
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path5.basename)(f).startsWith("index."));
   for (const absPath of fileSet) {
     const id = toNodeId(srcDir, absPath);
     const type = classifyType(absPath, id);
@@ -1010,7 +1025,7 @@ function generate(rootDir) {
       const dbCalls = extractDbCallsTS(absPath);
       const authWrappers = extractAuthWrappersTS(absPath);
       const deep = extractDeep(absPath);
-      const routePath = (0, import_node_fs4.existsSync)(apiDir) ? filePathToApiRoute(apiDir, absPath) : `/api/${id.replace(/\/route\.tsx?$/, "")}`;
+      const routePath = (0, import_node_fs5.existsSync)(apiDir) ? filePathToApiRoute(apiDir, absPath) : `/api/${id.replace(/\/route\.tsx?$/, "")}`;
       const mutations = dbCalls.filter((c) => c.isMutation);
       const mutates = mutations.length > 0;
       const authStrategy = [...authWrappers];
@@ -1087,20 +1102,7 @@ function generate(rootDir) {
     });
   }
   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);
+  const externalCandidates = walkWithIgnore(rootDir, [".ts", ".tsx"], { extraIgnore: /* @__PURE__ */ new Set(["src"]) });
   for (const absPath of externalCandidates) {
     const normalized = absPath.replace(/\\/g, "/");
     if (externalScanned.has(normalized)) continue;
@@ -1110,7 +1112,7 @@ function generate(rootDir) {
     } catch {
       continue;
     }
-    const externalId = (0, import_node_path4.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const externalId = (0, import_node_path5.relative)(rootDir, absPath).replace(/\\/g, "/");
     const edgesFromThis = [];
     const seen = /* @__PURE__ */ new Set();
     for (const imp of parsed.imports) {
@@ -1314,8 +1316,8 @@ var typescriptProjectParser = {
 };
 
 // src/server/graph/parsers/db/prisma-schema.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
 function parseModels(content) {
   const nodes = [];
   const relations = [];
@@ -1406,11 +1408,11 @@ function parseEnums(content) {
   return nodes;
 }
 function detect2(rootDir) {
-  return (0, import_node_fs5.existsSync)((0, import_node_path5.join)(rootDir, "prisma", "schema.prisma"));
+  return (0, import_node_fs6.existsSync)((0, import_node_path6.join)(rootDir, "prisma", "schema.prisma"));
 }
 function generate2(rootDir) {
-  const schemaPath = (0, import_node_path5.join)(rootDir, "prisma", "schema.prisma");
-  const content = (0, import_node_fs5.readFileSync)(schemaPath, "utf-8");
+  const schemaPath = (0, import_node_path6.join)(rootDir, "prisma", "schema.prisma");
+  const content = (0, import_node_fs6.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -1467,8 +1469,8 @@ var prismaSchemaParser = {
 };
 
 // src/server/graph/parsers/db/sql-migrations.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path7 = require("node:path");
 var PG_TO_PRISMA = {
   "TEXT": "String",
   "VARCHAR": "String",
@@ -1618,19 +1620,19 @@ function parseUniqueIndex(sql, state) {
   }
 }
 function parseMigrations(rootDir) {
-  const migrationsDir = (0, import_node_path6.join)(rootDir, "prisma", "migrations");
+  const migrationsDir = (0, import_node_path7.join)(rootDir, "prisma", "migrations");
   const state = {
     tables: /* @__PURE__ */ new Map(),
     enums: /* @__PURE__ */ new Map(),
     fks: [],
     uniqueIndexes: /* @__PURE__ */ new Map()
   };
-  if (!(0, import_node_fs6.existsSync)(migrationsDir)) return state;
-  const dirs = (0, import_node_fs6.readdirSync)(migrationsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  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_path6.join)(migrationsDir, dir, "migration.sql");
-    if (!(0, import_node_fs6.existsSync)(sqlPath)) continue;
-    const sql = (0, import_node_fs6.readFileSync)(sqlPath, "utf-8");
+    const sqlPath = (0, import_node_path7.join)(migrationsDir, dir, "migration.sql");
+    if (!(0, import_node_fs7.existsSync)(sqlPath)) continue;
+    const sql = (0, import_node_fs7.readFileSync)(sqlPath, "utf-8");
     parseCreateEnum(sql, state);
     parseCreateTable(sql, state);
     parseAlterTable(sql, state);
@@ -1641,9 +1643,9 @@ function parseMigrations(rootDir) {
   return state;
 }
 function loadPrismaState(rootDir) {
-  const schemaPath = (0, import_node_path6.join)(rootDir, "prisma", "schema.prisma");
-  if (!(0, import_node_fs6.existsSync)(schemaPath)) return null;
-  const content = (0, import_node_fs6.readFileSync)(schemaPath, "utf-8");
+  const schemaPath = (0, import_node_path7.join)(rootDir, "prisma", "schema.prisma");
+  if (!(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();
   const relations = [];
@@ -1808,9 +1810,9 @@ function verify(sqlState, prisma) {
   return { contradictions, flaggedEdges };
 }
 function detect3(rootDir) {
-  const migrationsDir = (0, import_node_path6.join)(rootDir, "prisma", "migrations");
-  if (!(0, import_node_fs6.existsSync)(migrationsDir)) return false;
-  return (0, import_node_fs6.readdirSync)(migrationsDir, { withFileTypes: true }).some((d) => d.isDirectory() && (0, import_node_fs6.existsSync)((0, import_node_path6.join)(migrationsDir, d.name, "migration.sql")));
+  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")));
 }
 function generate3(rootDir) {
   const sqlState = parseMigrations(rootDir);
@@ -2098,32 +2100,32 @@ var fetchResolverParser = {
 };
 
 // src/server/graph/parsers/crosslayer/api-annotations.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path8 = 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_fs7.existsSync)(dir)) return [];
+  if (!(0, import_node_fs8.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
+  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_path7.join)(dir, entry.name);
+    const full = (0, import_node_path8.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk2(full, exts));
-    } else if (exts.includes((0, import_node_path7.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path8.extname)(entry.name))) {
       results.push(full);
     }
   }
   return results;
 }
 function toNodeId2(srcDir, absPath) {
-  return (0, import_node_path7.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path8.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
 var apiAnnotationsParser = {
   id: "api-annotations",
   layer: "crosslayer",
   concern: "api-binding",
   detect(rootDir) {
-    return (0, import_node_fs7.existsSync)((0, import_node_path7.join)(rootDir, "src"));
+    return (0, import_node_fs8.existsSync)((0, import_node_path8.join)(rootDir, "src"));
   },
   generate(rootDir, layerOutputs) {
     const apiOutput = layerOutputs.get("api");
@@ -2134,13 +2136,13 @@ 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_path7.join)(rootDir, "src");
+    const srcDir = (0, import_node_path8.join)(rootDir, "src");
     const files = walk2(srcDir, [".ts", ".tsx"]);
     const crossRefs = [];
     const flaggedEdges = [];
     const seen = /* @__PURE__ */ new Set();
     for (const absPath of files) {
-      const content = (0, import_node_fs7.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs8.readFileSync)(absPath, "utf-8");
       const sourceId = toNodeId2(srcDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
       let match;
@@ -2184,26 +2186,26 @@ var apiAnnotationsParser = {
 };
 
 // src/server/graph/parsers/crosslayer/url-literal-scanner.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path9 = require("node:path");
 init_config();
 var URL_LITERAL_RE = /['"`](\/api\/[^'"`\s]+?)['"`]/g;
 function walk3(dir, exts) {
-  if (!(0, import_node_fs8.existsSync)(dir)) return [];
+  if (!(0, import_node_fs9.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true })) {
+  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_path8.join)(dir, entry.name);
+    const full = (0, import_node_path9.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk3(full, exts));
-    } else if (exts.includes((0, import_node_path8.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path9.extname)(entry.name))) {
       results.push(full);
     }
   }
   return results;
 }
 function toNodeId3(srcDir, absPath) {
-  return (0, import_node_path8.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path9.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
 var urlLiteralScannerParser = {
   id: "url-literal-scanner",
@@ -2224,7 +2226,7 @@ var urlLiteralScannerParser = {
     const apiPathMap = buildApiPathMap(apiRoutes);
     const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
     const srcDir = paths.srcDir;
-    const clientDir = (0, import_node_path8.join)(srcDir, "client");
+    const clientDir = (0, import_node_path9.join)(srcDir, "client");
     const files = [
       ...walk3(clientDir, [".ts", ".tsx"]),
       ...walk3(paths.appDir, [".ts", ".tsx"])
@@ -2234,7 +2236,7 @@ var urlLiteralScannerParser = {
     for (const absPath of files) {
       const sourceId = toNodeId3(srcDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
-      const content = (0, import_node_fs8.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs9.readFileSync)(absPath, "utf-8");
       let match;
       URL_LITERAL_RE.lastIndex = 0;
       while ((match = URL_LITERAL_RE.exec(content)) !== null) {
@@ -2265,8 +2267,8 @@ var urlLiteralScannerParser = {
 };
 
 // src/server/graph/parsers/static/static-values.ts
-var import_node_fs9 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path10 = require("node:path");
 var parseCode = null;
 function tryLoadTreeSitter() {
   if (parseCode) return true;
@@ -2299,19 +2301,19 @@ function extractEnumValues(rootDir) {
   const nodes = [];
   const edges = [];
   const schemaPaths = [
-    (0, import_node_path9.join)(rootDir, "prisma", "schema.prisma"),
-    (0, import_node_path9.join)(rootDir, "prisma", "schema")
+    (0, import_node_path10.join)(rootDir, "prisma", "schema.prisma"),
+    (0, import_node_path10.join)(rootDir, "prisma", "schema")
   ];
   let content = "";
   for (const p of schemaPaths) {
-    if ((0, import_node_fs9.existsSync)(p)) {
+    if ((0, import_node_fs10.existsSync)(p)) {
       try {
-        const stat = (0, import_node_fs9.statSync)(p);
+        const stat = (0, import_node_fs10.statSync)(p);
         if (stat.isFile()) {
-          content = (0, import_node_fs9.readFileSync)(p, "utf-8");
+          content = (0, import_node_fs10.readFileSync)(p, "utf-8");
         } else if (stat.isDirectory()) {
-          const files = (0, import_node_fs9.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
-          content = files.map((f) => (0, import_node_fs9.readFileSync)((0, import_node_path9.join)(p, f), "utf-8")).join("\n");
+          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");
         }
       } catch {
         continue;
@@ -2385,7 +2387,7 @@ function extractStringArrayFromNode(node) {
   return values;
 }
 function findArrayDecl(root, varName) {
-  function walk5(node) {
+  function walk4(node) {
     if (node.type === "variable_declarator") {
       const nameNode = node.childForFieldName("name");
       const valueNode = node.childForFieldName("value");
@@ -2398,12 +2400,12 @@ function findArrayDecl(root, varName) {
       }
     }
     for (const child of node.namedChildren) {
-      const found = walk5(child);
+      const found = walk4(child);
       if (found) return found;
     }
     return null;
   }
-  return walk5(root);
+  return walk4(root);
 }
 function extractObjectPropsRegex(objStr) {
   const props = {};
@@ -2467,14 +2469,14 @@ function extractSeedData(rootDir) {
   const nodes = [];
   const edges = [];
   const seedFiles = [
-    (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_fs9.existsSync);
+    (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")
+  ].filter(import_node_fs10.existsSync);
   const useTreeSitter = tryLoadTreeSitter();
   for (const filePath of seedFiles) {
-    const content = (0, import_node_fs9.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path9.relative)(rootDir, filePath);
+    const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path10.relative)(rootDir, filePath);
     const seeded = detectSeededArrays(content, relPath);
     let astRoot = null;
     if (useTreeSitter && parseCode) {
@@ -2568,11 +2570,11 @@ function extractSeedData(rootDir) {
   return { nodes, edges };
 }
 function walkDir(dir, exts) {
-  if (!(0, import_node_fs9.existsSync)(dir)) return [];
+  if (!(0, import_node_fs10.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true })) {
+  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_path9.join)(dir, entry.name);
+    const full = (0, import_node_path10.join)(dir, entry.name);
     if (entry.isDirectory()) results.push(...walkDir(full, exts));
     else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(full);
   }
@@ -2580,11 +2582,11 @@ function walkDir(dir, exts) {
 }
 function extractConstants(rootDir) {
   const nodes = [];
-  const srcDir = (0, import_node_path9.join)(rootDir, "src");
-  if (!(0, import_node_fs9.existsSync)(srcDir)) return { nodes };
+  const srcDir = (0, import_node_path10.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_fs9.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path9.relative)(rootDir, filePath);
+    const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path10.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) {
@@ -2617,7 +2619,7 @@ function extractConstants(rootDir) {
   return { nodes };
 }
 function detect4(rootDir) {
-  return (0, import_node_fs9.existsSync)((0, import_node_path9.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs9.existsSync)((0, import_node_path9.join)(rootDir, "prisma", "seed.ts"));
+  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"));
 }
 function generate4(rootDir) {
   const enumResult = extractEnumValues(rootDir);
@@ -2692,26 +2694,9 @@ var staticValuesParser = {
 };
 
 // src/server/graph/parsers/crosslayer/static-ref-scanner.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path11 = require("node:path");
 init_config();
-function walk4(dir, exts) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return [];
-  const results = [];
-  function recurse(d) {
-    for (const entry of (0, import_node_fs10.readdirSync)(d, { withFileTypes: true })) {
-      const full = (0, import_node_path10.join)(d, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
-        recurse(full);
-      } else if (exts.some((ext) => entry.name.endsWith(ext))) {
-        results.push(full);
-      }
-    }
-  }
-  recurse(dir);
-  return results;
-}
 var MIN_VALUE_LENGTH = 4;
 var SKIP_VALUES = /* @__PURE__ */ new Set([
   "true",
@@ -2854,11 +2839,11 @@ var staticRefScannerParser = {
     if (!paths) return { cross_refs: [], flagged_edges: [], warnings: [] };
     const srcDir = paths.srcDir;
     const files = [
-      ...walk4((0, import_node_path10.join)(srcDir, "client"), [".ts", ".tsx"]),
-      ...walk4(paths.appDir, [".ts", ".tsx"]),
-      ...walk4((0, import_node_path10.join)(srcDir, "server"), [".ts", ".tsx"]),
-      ...walk4((0, import_node_path10.join)(srcDir, "lib"), [".ts", ".tsx"]),
-      ...walk4((0, import_node_path10.join)(srcDir, "config"), [".ts", ".tsx"])
+      ...walkWithIgnore((0, import_node_path11.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"])
     ];
     const uiOutput = layerOutputs.get("ui");
     const apiOutput = layerOutputs.get("api");
@@ -2876,10 +2861,10 @@ var staticRefScannerParser = {
     const seen = /* @__PURE__ */ new Set();
     let filesScanned = 0;
     for (const absPath of files) {
-      const sourceId = (0, import_node_path10.relative)(srcDir, absPath).replace(/\\/g, "/");
+      const sourceId = (0, import_node_path11.relative)(srcDir, absPath).replace(/\\/g, "/");
       const sourceLayer = uiNodeIds.has(sourceId) ? "ui" : apiNodeIds.has(sourceId) ? "api" : null;
       if (!sourceLayer) continue;
-      const content = (0, import_node_fs10.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs11.readFileSync)(absPath, "utf-8");
       filesScanned++;
       let fileRefs;
       if (parseCode2) {
@@ -2995,7 +2980,7 @@ function registerBuiltins(registry, disabled) {
 function loadCustomParsers(registry, config, rootDir, disabled) {
   for (const entry of config.parsers?.custom ?? []) {
     try {
-      const absPath = (0, import_node_path11.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path12.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const parser = "default" in mod ? mod.default : mod;
       if (disabled.has(parser.id)) continue;
@@ -3125,10 +3110,10 @@ function applyCrossLayerResults(uiOutput, results) {
 
 // src/server/graph/core/graph-builder.ts
 function readGraphFromDisk(rootDir, layer) {
-  const filePath = (0, import_node_path12.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
-  if (!(0, import_node_fs11.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path13.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
+  if (!(0, import_node_fs12.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs11.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs12.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -3229,11 +3214,11 @@ function generateAll(rootDir) {
 init_config();
 
 // src/server/graph/core/tagger-registry.ts
-var import_node_path14 = require("node:path");
+var import_node_path15 = require("node:path");
 
 // src/server/graph/taggers/module-tagger.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path14 = require("node:path");
 function matchGlob(pattern, id) {
   const patParts = pattern.split("/");
   const idParts = id.split("/");
@@ -3266,18 +3251,18 @@ function detectConventionDirs(rootDir, extraConventionDirs = []) {
   const conventionDirs = [...CONVENTION_DIRS_BUILTIN, ...extraConventionDirs];
   const searchDirs = [
     rootDir,
-    (0, import_node_path13.join)(rootDir, "src"),
-    (0, import_node_path13.join)(rootDir, "app"),
-    (0, import_node_path13.join)(rootDir, "lib")
+    (0, import_node_path14.join)(rootDir, "src"),
+    (0, import_node_path14.join)(rootDir, "app"),
+    (0, import_node_path14.join)(rootDir, "lib")
   ];
   for (const base of searchDirs) {
     for (const convention of conventionDirs) {
-      const dir = (0, import_node_path13.join)(base, convention);
-      if (!(0, import_node_fs12.existsSync)(dir)) continue;
+      const dir = (0, import_node_path14.join)(base, convention);
+      if (!(0, import_node_fs13.existsSync)(dir)) continue;
       try {
-        const stat = (0, import_node_fs12.statSync)(dir);
+        const stat = (0, import_node_fs13.statSync)(dir);
         if (!stat.isDirectory()) continue;
-        const entries = (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+        const entries = (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
         if (entries.length > 0) {
           const relPath = dir.replace(rootDir + "/", "").replace(rootDir + "\\", "");
           result.set(relPath, entries);
@@ -3571,7 +3556,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_path14.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path15.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const tagger = "default" in mod ? mod.default : mod;
       const override = config.taggers?.trackUntagged?.[tagger.id];
@@ -3594,24 +3579,24 @@ function createTaggerRegistry(config, rootDir) {
 }
 
 // src/server/graph/core/tag-store.ts
-var import_node_fs13 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path16 = 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_path15.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
+  return (0, import_node_path16.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
 }
 function readTagStore(rootDir) {
   const filePath = tagsFilePath(rootDir);
-  if (!(0, import_node_fs13.existsSync)(filePath)) return {};
-  const stat = (0, import_node_fs13.statSync)(filePath);
+  if (!(0, import_node_fs14.existsSync)(filePath)) return {};
+  const stat = (0, import_node_fs14.statSync)(filePath);
   const cached = tagCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.store;
   }
   try {
-    const content = (0, import_node_fs13.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs14.readFileSync)(filePath, "utf-8");
     const store = JSON.parse(content);
     tagCache.set(filePath, { mtimeMs: stat.mtimeMs, store });
     return store;
@@ -3621,15 +3606,15 @@ function readTagStore(rootDir) {
 }
 function writeTagStore(rootDir, store) {
   const filePath = tagsFilePath(rootDir);
-  const dir = (0, import_node_path15.dirname)(filePath);
-  (0, import_node_fs13.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path16.dirname)(filePath);
+  (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
   const cleaned = {};
   for (const [nodeId, tags] of Object.entries(store)) {
     if (Object.keys(tags).length > 0) {
       cleaned[nodeId] = tags;
     }
   }
-  (0, import_node_fs13.writeFileSync)(filePath, JSON.stringify(cleaned, null, 2) + "\n", "utf-8");
+  (0, import_node_fs14.writeFileSync)(filePath, JSON.stringify(cleaned, null, 2) + "\n", "utf-8");
   tagCache.delete(filePath);
 }
 function setTag(rootDir, nodeId, key, value) {
@@ -3652,24 +3637,24 @@ function removeTag(rootDir, nodeId, key) {
 init_ts_extractor();
 var GRAPHS_DIR2 = ".launchsecure/graphs";
 function getAvailableLayers(rootDir) {
-  const dir = (0, import_node_path16.join)(rootDir, GRAPHS_DIR2);
-  if (!(0, import_node_fs14.existsSync)(dir)) return [];
-  return (0, import_node_fs14.readdirSync)(dir).filter((f) => f.endsWith(".json") && f !== "tags.json").map((f) => f.replace(".json", ""));
+  const dir = (0, import_node_path17.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_path16.join)(rootDir, GRAPHS_DIR2);
+  return (0, import_node_path17.join)(rootDir, GRAPHS_DIR2);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path16.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path17.join)(graphsDir(rootDir), `${layer}.json`);
 }
 function tagsFilePath2(rootDir) {
-  return (0, import_node_path16.join)(graphsDir(rootDir), "tags.json");
+  return (0, import_node_path17.join)(graphsDir(rootDir), "tags.json");
 }
 function getMtimeMs(filePath) {
-  if (!(0, import_node_fs14.existsSync)(filePath)) return 0;
-  return (0, import_node_fs14.statSync)(filePath).mtimeMs;
+  if (!(0, import_node_fs15.existsSync)(filePath)) return 0;
+  return (0, import_node_fs15.statSync)(filePath).mtimeMs;
 }
 function invalidateCache(filePath) {
   graphCache.delete(filePath);
@@ -3708,20 +3693,20 @@ function applyTags(graph, layer, rootDir) {
 }
 function readGraphRaw(rootDir, layer) {
   const filePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs14.existsSync)(filePath)) return null;
-  const stat = (0, import_node_fs14.statSync)(filePath);
+  if (!(0, import_node_fs15.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs15.statSync)(filePath);
   const cached = graphCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.graph;
   }
-  const content = (0, import_node_fs14.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs15.readFileSync)(filePath, "utf-8");
   const graph = JSON.parse(content);
   graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
   return graph;
 }
 function readGraph(rootDir, layer) {
   const rawFilePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs14.existsSync)(rawFilePath)) return null;
+  if (!(0, import_node_fs15.existsSync)(rawFilePath)) return null;
   const rawMtime = getMtimeMs(rawFilePath);
   const tagsMtime = getMtimeMs(tagsFilePath2(rootDir));
   const cacheKey = `${rootDir}:${layer}`;
@@ -3751,11 +3736,11 @@ async function generateGraph(rootDir, layer) {
     mutationMethods: config.parsers?.patterns?.mutationMethods
   });
   const dir = graphsDir(rootDir);
-  (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs15.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_fs14.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
+    (0, import_node_fs15.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
     invalidateCache(filePath);
     invalidateTaggedCache(rootDir, result.layer);
   }
@@ -3764,28 +3749,28 @@ async function generateGraph(rootDir, layer) {
 
 // src/server/lockfile.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs15 = require("node:fs");
+var import_node_fs16 = require("node:fs");
 var import_node_os = require("node:os");
-var import_node_path17 = require("node:path");
+var import_node_path18 = require("node:path");
 function lockDir(projectRoot) {
   if (projectRoot) {
-    return (0, import_node_path17.join)(projectRoot, ".launchsecure");
+    return (0, import_node_path18.join)(projectRoot, ".launchsecure");
   }
-  return (0, import_node_path17.join)((0, import_node_os.homedir)(), ".launchsecure");
+  return (0, import_node_path18.join)((0, import_node_os.homedir)(), ".launchsecure");
 }
 function lockPath(projectRoot) {
-  return (0, import_node_path17.join)(lockDir(projectRoot), "launch-chart.lock");
+  return (0, import_node_path18.join)(lockDir(projectRoot), "launch-chart.lock");
 }
 var _activeProjectRoot;
 function readLock(projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
   const p = lockPath(root);
-  if (!(0, import_node_fs15.existsSync)(p)) {
+  if (!(0, import_node_fs16.existsSync)(p)) {
     if (root) {
       const globalP = lockPath();
-      if ((0, import_node_fs15.existsSync)(globalP)) {
+      if ((0, import_node_fs16.existsSync)(globalP)) {
         try {
-          const data = JSON.parse((0, import_node_fs15.readFileSync)(globalP, "utf-8"));
+          const data = JSON.parse((0, import_node_fs16.readFileSync)(globalP, "utf-8"));
           if (typeof data.pid === "number" && typeof data.port === "number" && data.cwd === root) {
             return data;
           }
@@ -3796,7 +3781,7 @@ function readLock(projectRoot) {
     return null;
   }
   try {
-    const data = JSON.parse((0, import_node_fs15.readFileSync)(p, "utf-8"));
+    const data = JSON.parse((0, import_node_fs16.readFileSync)(p, "utf-8"));
     if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
     return data;
   } catch {
@@ -3833,7 +3818,7 @@ function getLiveLock(projectRoot) {
   const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
   if (!live) {
     try {
-      (0, import_node_fs15.unlinkSync)(lockPath(root));
+      (0, import_node_fs16.unlinkSync)(lockPath(root));
     } catch {
     }
     return null;
@@ -3842,14 +3827,14 @@ function getLiveLock(projectRoot) {
 }
 function writeLock(data, projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
-  (0, import_node_fs15.mkdirSync)(lockDir(root), { recursive: true });
-  (0, import_node_fs15.writeFileSync)(lockPath(root), JSON.stringify(data, null, 2) + "\n", "utf-8");
+  (0, import_node_fs16.mkdirSync)(lockDir(root), { recursive: true });
+  (0, import_node_fs16.writeFileSync)(lockPath(root), JSON.stringify(data, null, 2) + "\n", "utf-8");
   if (root) _activeProjectRoot = root;
 }
 function clearLock(projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
   try {
-    (0, import_node_fs15.unlinkSync)(lockPath(root));
+    (0, import_node_fs16.unlinkSync)(lockPath(root));
   } catch {
   }
 }
@@ -3858,13 +3843,13 @@ function clearLock(projectRoot) {
 init_config();
 
 // src/server/graph/core/audit-core.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_path19 = require("node:path");
 function readGraphFile(rootDir, layer) {
-  const filePath = (0, import_node_path18.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
-  if (!(0, import_node_fs16.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path19.join)(rootDir, ".launchsecure", "graphs", `${layer}.json`);
+  if (!(0, import_node_fs17.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs16.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs17.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -3908,10 +3893,10 @@ 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_path18.join)(rootDir, "src", "config", "route-permissions.ts");
+  const routePermsPath = (0, import_node_path19.join)(rootDir, "src", "config", "route-permissions.ts");
   let routePermsContent = "";
-  if ((0, import_node_fs16.existsSync)(routePermsPath)) {
-    routePermsContent = (0, import_node_fs16.readFileSync)(routePermsPath, "utf-8");
+  if ((0, import_node_fs17.existsSync)(routePermsPath)) {
+    routePermsContent = (0, import_node_fs17.readFileSync)(routePermsPath, "utf-8");
   }
   const registeredRoutes = /* @__PURE__ */ new Set();
   const routeEntryRe = /path:\s*'([^']+)'/g;
@@ -3988,10 +3973,10 @@ 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_path18.join)(rootDir, "src", "config", "route-permissions.ts");
+  const routePermsPath = (0, import_node_path19.join)(rootDir, "src", "config", "route-permissions.ts");
   let routePermsContent = "";
-  if ((0, import_node_fs16.existsSync)(routePermsPath)) {
-    routePermsContent = (0, import_node_fs16.readFileSync)(routePermsPath, "utf-8");
+  if ((0, import_node_fs17.existsSync)(routePermsPath)) {
+    routePermsContent = (0, import_node_fs17.readFileSync)(routePermsPath, "utf-8");
   }
   for (const perm of permissions) {
     const regex = new RegExp(`permission:\\s*['"]${perm.key}['"]`);
@@ -4021,9 +4006,9 @@ function checkHardcodedValues(rootDir) {
   const seen = /* @__PURE__ */ new Set();
   for (const node of api.nodes) {
     if (node.type !== "endpoint") continue;
-    const filePath = (0, import_node_path18.join)(rootDir, "src", node.id);
-    if (!(0, import_node_fs16.existsSync)(filePath)) continue;
-    const content = (0, import_node_fs16.readFileSync)(filePath, "utf-8");
+    const filePath = (0, import_node_path19.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;
     allCapsRe.lastIndex = 0;
     while ((m = allCapsRe.exec(content)) !== null) {
@@ -4153,16 +4138,16 @@ var MIME_TYPES = {
 function findProjectRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
-    const graphsDir2 = import_node_path19.default.join(dir, ".launchsecure", "graphs");
-    if (import_node_fs17.default.existsSync(import_node_path19.default.join(graphsDir2, "ui.json")) || import_node_fs17.default.existsSync(import_node_path19.default.join(graphsDir2, "api.json")) || import_node_fs17.default.existsSync(import_node_path19.default.join(graphsDir2, "db.json"))) return dir;
-    const parent = import_node_path19.default.dirname(dir);
+    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);
     if (parent === dir) break;
     dir = parent;
   }
   dir = startDir;
   for (let i = 0; i < 8; i++) {
-    if (import_node_fs17.default.existsSync(import_node_path19.default.join(dir, ".git"))) return dir;
-    const parent = import_node_path19.default.dirname(dir);
+    if (import_node_fs18.default.existsSync(import_node_path20.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path20.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4171,7 +4156,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_path19.default.resolve(monorepoRoot, projectParam);
+  const resolved = import_node_path20.default.resolve(monorepoRoot, projectParam);
   if (!resolved.startsWith(monorepoRoot)) {
     throw new Error("Project path outside monorepo root");
   }
@@ -4222,16 +4207,16 @@ async function buildMergedGraph(root) {
   };
 }
 function serveStatic(res, filePath) {
-  if (!import_node_fs17.default.existsSync(filePath) || !import_node_fs17.default.statSync(filePath).isFile()) return false;
-  const ext = import_node_path19.default.extname(filePath).toLowerCase();
+  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 mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
-  import_node_fs17.default.createReadStream(filePath).pipe(res);
+  import_node_fs18.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function serveIndex(res, clientDir) {
-  const indexPath = import_node_path19.default.join(clientDir, "index.html");
-  if (!import_node_fs17.default.existsSync(indexPath)) {
+  const indexPath = import_node_path20.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'.`);
     return;
@@ -4283,7 +4268,7 @@ async function startChartServer(opts = {}) {
     }
     return { port: existing.port, url: existing.url };
   }
-  const clientDir = opts.clientDir ?? import_node_path19.default.join(__dirname, "..", "chart-client");
+  const clientDir = opts.clientDir ?? import_node_path20.default.join(__dirname, "..", "chart-client");
   const rootConfig = loadConfig(projectRoot);
   const projects = rootConfig.projects ?? [];
   const server = import_node_http.default.createServer((req, res) => {
@@ -4299,11 +4284,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_path19.default.resolve(projectRoot, p.root);
-          const hasGraphs = import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, ".launchsecure", "graphs"));
-          const hasNextConfig2 = import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, "next.config.ts")) || import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, "next.config.js")) || import_node_fs17.default.existsSync(import_node_path19.default.join(absRoot, "next.config.mjs"));
-          return { name: p.name, root: p.root, hasGraphs, hasNextConfig: hasNextConfig2 };
-        }) : [{ name: import_node_path19.default.basename(projectRoot), root: ".", hasGraphs: import_node_fs17.default.existsSync(import_node_path19.default.join(projectRoot, ".launchsecure", "graphs")), hasNextConfig: true }];
+          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"));
+          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 }];
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ projects: projectList, monorepoRoot: projectRoot }));
         return;
@@ -4349,20 +4334,20 @@ 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_path19.default.isAbsolute(relPath)) {
+        if (!relPath || relPath.includes("..") || import_node_path20.default.isAbsolute(relPath)) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "Invalid path" }));
           return;
         }
-        const filePath = import_node_path19.default.join(reqRoot, relPath);
-        if (!filePath.startsWith(reqRoot) || !import_node_fs17.default.existsSync(filePath) || !import_node_fs17.default.statSync(filePath).isFile()) {
+        const filePath = import_node_path20.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_path19.default.extname(filePath).toLowerCase();
+        const ext = import_node_path20.default.extname(filePath).toLowerCase();
         const langMap = { ".ts": "typescript", ".tsx": "tsx", ".js": "javascript", ".jsx": "jsx", ".prisma": "prisma", ".json": "json", ".css": "css" };
-        const content = import_node_fs17.default.readFileSync(filePath, "utf-8");
+        const content = import_node_fs18.default.readFileSync(filePath, "utf-8");
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ content, language: langMap[ext] ?? "text", path: relPath }));
         return;
@@ -4404,8 +4389,8 @@ async function startChartServer(opts = {}) {
         req.on("end", () => {
           try {
             const newConfig = JSON.parse(body);
-            const configPath = import_node_path19.default.join(reqRoot, ".launchchart.json");
-            import_node_fs17.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+            const configPath = import_node_path20.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 }));
           } catch (err) {
@@ -4438,8 +4423,8 @@ async function startChartServer(opts = {}) {
             const taggerConfig = JSON.parse(body);
             const config2 = loadConfig(reqRoot);
             config2.taggers = taggerConfig;
-            const configPath = import_node_path19.default.join(reqRoot, ".launchchart.json");
-            import_node_fs17.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+            const configPath = import_node_path20.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 }));
           } catch (err) {
@@ -4512,10 +4497,10 @@ async function startChartServer(opts = {}) {
         res.end(JSON.stringify({
           projectRoot: reqRoot,
           detected: paths ? {
-            srcDir: import_node_path19.default.relative(reqRoot, paths.srcDir) || ".",
-            appDir: import_node_path19.default.relative(reqRoot, paths.appDir),
-            apiDir: import_node_path19.default.relative(reqRoot, paths.apiDir),
-            dbDir: paths.dbDir ? import_node_path19.default.relative(reqRoot, paths.dbDir) : null
+            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
           } : null,
           overrides,
           isOverride: overrides.appDir
@@ -4524,19 +4509,19 @@ async function startChartServer(opts = {}) {
       }
       if (req.method === "GET" && url2.pathname === "/api/browse-dir") {
         const browsePath = url2.searchParams.get("path") || projectRoot;
-        const abs = import_node_path19.default.resolve(browsePath);
-        const twoUp = import_node_path19.default.resolve(projectRoot, "..", "..");
+        const abs = import_node_path20.default.resolve(browsePath);
+        const twoUp = import_node_path20.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" }));
           return;
         }
         try {
-          const entries = import_node_fs17.default.readdirSync(abs, { withFileTypes: true });
+          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_path19.default.dirname(abs) : null;
+          const parent = abs !== twoUp ? import_node_path20.default.dirname(abs) : null;
           res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ current: abs, parent, dirs, relative: import_node_path19.default.relative(projectRoot, abs) || "." }));
+          res.end(JSON.stringify({ current: abs, parent, dirs, relative: import_node_path20.default.relative(projectRoot, abs) || "." }));
         } catch (err) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ ok: false, error: String(err) }));
@@ -4562,8 +4547,8 @@ 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_path19.default.join(projectRoot, ".launchchart.json");
-            import_node_fs17.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+            const configPath = import_node_path20.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);
             res.writeHead(200, { "Content-Type": "application/json" });
@@ -4576,7 +4561,7 @@ async function startChartServer(opts = {}) {
         return;
       }
       if (url2.pathname !== "/") {
-        const staticPath = import_node_path19.default.join(clientDir, url2.pathname);
+        const staticPath = import_node_path20.default.join(clientDir, url2.pathname);
         if (serveStatic(res, staticPath)) return;
       }
       serveIndex(res, clientDir);