@launchsecure/launch-kit 0.0.39 → 0.0.40

package/dist/server/chart-serve.js

@@ -131,8 +131,8 @@ function getQuery(name) {
   ensureInit();
   const cached = queryCache.get(name);
   if (cached) return cached;
-  const scmPath = (0, import_node_path13.join)(queriesDir, `${name}.scm`);
-  const scm = (0, import_node_fs11.readFileSync)(scmPath, "utf-8");
+  const scmPath = (0, import_node_path16.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs12.readFileSync)(scmPath, "utf-8");
   const query = tsxLanguage.query(scm);
   queryCache.set(name, query);
   return query;
@@ -152,13 +152,13 @@ function parseSource(absPath) {
   ensureInit();
   let content;
   try {
-    const stat = (0, import_node_fs11.statSync)(absPath);
+    const stat = (0, import_node_fs12.statSync)(absPath);
     if (stat.size > MAX_PARSEABLE_BYTES) {
       process.stderr.write(`[lc-extractor] skipping ${absPath}: ${stat.size} bytes exceeds max ${MAX_PARSEABLE_BYTES}
 `);
       return null;
     }
-    content = (0, import_node_fs11.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs12.readFileSync)(absPath, "utf-8");
   } catch (e) {
     process.stderr.write(`[lc-extractor] read failed for ${absPath}: ${e instanceof Error ? e.message : String(e)}
 `);
@@ -1192,18 +1192,18 @@ function collectUiLabels(root) {
   visit(root);
   return out;
 }
-var import_node_fs11, import_node_path13, tsxLanguage, parserInstance, TreeSitterCtor, initPromise, initialized, queriesDir, queryCache, MAX_PARSEABLE_BYTES, MAX_CONSECUTIVE_PARSE_FAILURES, consecutiveParseFailures, ParseCascadeError, PRISMA_MUTATION_METHODS_BUILTIN, SUPABASE_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods, INLINE_AUTH_IMPORTS, EXEMPT_NAME_PATTERNS, PROTECT_NAME_PATTERNS, TRUST_AS_PROTECT_KEYS, TIMER_FNS, DOM_METHOD_NAMES, CLASSLIST_METHODS, STORAGE_OBJECTS, HISTORY_METHODS, LOCATION_METHODS, ASSIGN_DOM_PROPS, UI_LABEL_KEYS, UI_LABELS_MAX, NOTE_REGEX, NOTES_MAX;
+var import_node_fs12, import_node_path16, tsxLanguage, parserInstance, TreeSitterCtor, initPromise, initialized, queriesDir, queryCache, MAX_PARSEABLE_BYTES, MAX_CONSECUTIVE_PARSE_FAILURES, consecutiveParseFailures, ParseCascadeError, PRISMA_MUTATION_METHODS_BUILTIN, SUPABASE_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods, INLINE_AUTH_IMPORTS, EXEMPT_NAME_PATTERNS, PROTECT_NAME_PATTERNS, TRUST_AS_PROTECT_KEYS, TIMER_FNS, DOM_METHOD_NAMES, CLASSLIST_METHODS, STORAGE_OBJECTS, HISTORY_METHODS, LOCATION_METHODS, ASSIGN_DOM_PROPS, UI_LABEL_KEYS, UI_LABELS_MAX, NOTE_REGEX, NOTES_MAX;
 var init_ts_extractor = __esm({
   "src/server/graph/core/ts-extractor.ts"() {
     "use strict";
-    import_node_fs11 = require("node:fs");
-    import_node_path13 = require("node:path");
+    import_node_fs12 = require("node:fs");
+    import_node_path16 = require("node:path");
     init_parse_failure_cache();
     initialized = false;
     queriesDir = (() => {
-      const srcPath = (0, import_node_path13.join)((0, import_node_path13.dirname)(__filename), "..", "queries");
+      const srcPath = (0, import_node_path16.join)((0, import_node_path16.dirname)(__filename), "..", "queries");
       if (require("fs").existsSync(srcPath)) return srcPath;
-      return (0, import_node_path13.join)((0, import_node_path13.dirname)(__filename), "graph", "queries");
+      return (0, import_node_path16.join)((0, import_node_path16.dirname)(__filename), "graph", "queries");
     })();
     queryCache = /* @__PURE__ */ new Map();
     MAX_PARSEABLE_BYTES = 2 * 1024 * 1024;
@@ -1343,13 +1343,13 @@ __export(chart_serve_exports, {
 });
 module.exports = __toCommonJS(chart_serve_exports);
 var import_node_http = __toESM(require("node:http"));
-var import_node_fs21 = __toESM(require("node:fs"));
-var import_node_path24 = __toESM(require("node:path"));
+var import_node_fs22 = __toESM(require("node:fs"));
+var import_node_path27 = __toESM(require("node:path"));
 init_launch_kit_paths();
 
 // src/server/graph/index.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path12 = require("node:path");
 init_config();
 
 // src/server/graph/core/tagger-registry.ts
@@ -1813,7 +1813,7 @@ function resolveWorkerPath() {
   );
 }
 function runParseInWorker(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let workerPath;
     try {
       workerPath = resolveWorkerPath();
@@ -1832,7 +1832,7 @@ function runParseInWorker(req) {
     };
     worker.on("message", (reply) => {
       if (reply.ok) {
-        finish(() => resolve4({ results: reply.results, failedFiles: reply.failedFiles }));
+        finish(() => resolve5({ results: reply.results, failedFiles: reply.failedFiles }));
       } else {
         const err = new Error(reply.error.message);
         err.name = reply.error.name;
@@ -1910,9 +1910,297 @@ function writeEffectsIndex(rootDir, idx) {
   return path2;
 }
 
-// src/server/graph/core/freshness.ts
+// src/server/graph/core/context-map.ts
+var import_node_path10 = require("node:path");
+init_launch_kit_paths();
+init_config();
+
+// src/server/graph/core/context/registry.ts
+var import_node_path9 = require("node:path");
+
+// src/server/graph/core/context/types.ts
+var CONTEXT_NODE_ACTION = "action";
+var CONTEXT_NODE_STATE = "state";
+var CONFIDENCE_RANK = { low: 0, medium: 1, high: 2 };
+function higherConfidence(a, b) {
+  return CONFIDENCE_RANK[a] >= CONFIDENCE_RANK[b] ? a : b;
+}
+function stateId(token) {
+  return `state:${token}`;
+}
+function actionId(key) {
+  return `action:${key}`;
+}
+function stateNode(token, label) {
+  return { id: stateId(token), type: CONTEXT_NODE_STATE, name: token, label };
+}
+function actionNode(key, name, meta = {}) {
+  return { id: actionId(key), type: CONTEXT_NODE_ACTION, name, ...meta };
+}
+function contextEdge(fromActionId, toStateId, type, confidence, origin) {
+  return { source: fromActionId, target: toStateId, type, label: `${type} (${origin})`, confidence, origin };
+}
+
+// src/server/graph/core/context/providers/nextjs-prisma.ts
+var PRODUCING_METHODS = /* @__PURE__ */ new Set(["create", "createMany", "upsert"]);
+function isPublic(auth) {
+  if (!auth || auth.length === 0) return true;
+  return auth.every((a) => a === "public");
+}
+function notFoundEntity(consequence) {
+  if (!consequence) return null;
+  const m = consequence.match(/notFound\(\s*['"]([A-Za-z0-9_]+)['"]/);
+  return m ? m[1] : null;
+}
+var nextjsPrismaContextProvider = {
+  id: "nextjs-prisma",
+  detect(layerOutputs) {
+    const api = layerOutputs["api"];
+    return !!api && (api.nodes ?? []).some((n) => n.type === "endpoint");
+  },
+  derive(layerOutputs) {
+    const api = layerOutputs["api"];
+    const states = /* @__PURE__ */ new Map();
+    const actions = [];
+    const edges = [];
+    const seenEdge = /* @__PURE__ */ new Set();
+    const ensureState = (token, label) => {
+      const id = stateId(token);
+      if (!states.has(id)) states.set(id, stateNode(token, label));
+      return id;
+    };
+    const addEdge = (from, to, type, confidence, origin) => {
+      const key = `${from}|${type}|${to}`;
+      if (seenEdge.has(key)) return;
+      seenEdge.add(key);
+      edges.push(contextEdge(from, to, type, confidence, origin));
+    };
+    const endpoints = (api?.nodes ?? []).filter((n) => n.type === "endpoint");
+    for (const ep of endpoints) {
+      const aId = actionId(ep.id);
+      actions.push(actionNode(ep.id, ep.name, { methods: ep.methods ?? [], endpoint: ep.id }));
+      if (!isPublic(ep.auth)) {
+        addEdge(aId, ensureState("session", "Authenticated session"), "requires", "high", "auth-wrapper");
+      }
+      for (const op of ep.db_operations ?? []) {
+        const [model, method] = op.split(".");
+        if (!model || !PRODUCING_METHODS.has(method ?? "")) continue;
+        addEdge(aId, ensureState(model, `${model} record exists`), "produces", "medium", `db:${op}`);
+      }
+      for (const cond of ep.conditions ?? []) {
+        const entity = notFoundEntity(cond.consequence);
+        if (!entity) continue;
+        const token = entity.toLowerCase();
+        addEdge(aId, ensureState(token, `${token} record exists`), "requires", "low", "guard:notFound");
+      }
+    }
+    return { nodes: [...actions, ...states.values()], edges };
+  }
+};
+
+// src/server/graph/core/context/overlay.ts
 var import_node_fs6 = require("node:fs");
 var import_node_path8 = require("node:path");
+var OVERLAY_FILE = ".launchchart.context.json";
+function overlayPath(rootDir) {
+  return (0, import_node_path8.join)(rootDir, OVERLAY_FILE);
+}
+function loadOverlay(rootDir) {
+  const path2 = overlayPath(rootDir);
+  if (!(0, import_node_fs6.existsSync)(path2)) return null;
+  try {
+    return JSON.parse((0, import_node_fs6.readFileSync)(path2, "utf-8"));
+  } catch (e) {
+    process.stderr.write(`[launch-chart] failed to parse ${OVERLAY_FILE}: ${e.message}
+`);
+    return null;
+  }
+}
+var overlayProvider = {
+  id: "overlay",
+  detect(_layerOutputs, rootDir) {
+    return (0, import_node_fs6.existsSync)(overlayPath(rootDir));
+  },
+  derive(_layerOutputs, rootDir) {
+    const overlay = loadOverlay(rootDir);
+    if (!overlay) return { nodes: [], edges: [] };
+    const nodes = /* @__PURE__ */ new Map();
+    const edges = [];
+    const seenEdge = /* @__PURE__ */ new Set();
+    const ensureState = (token, label) => {
+      const id = stateId(token);
+      if (!nodes.has(id)) nodes.set(id, stateNode(token, label ?? `${token} (overlay)`));
+      return id;
+    };
+    const ensureAction = (key, name) => {
+      const id = actionId(key);
+      if (!nodes.has(id)) nodes.set(id, actionNode(key, name ?? key, { source: "overlay" }));
+      return id;
+    };
+    for (const s of overlay.states ?? []) ensureState(s.token, s.label);
+    for (const a of overlay.actions ?? []) ensureAction(a.id, a.name);
+    for (const e of overlay.edges ?? []) {
+      const aId = ensureAction(e.action);
+      const link = (token, type) => {
+        const sId = ensureState(token);
+        const key = `${aId}|${type}|${sId}`;
+        if (seenEdge.has(key)) return;
+        seenEdge.add(key);
+        edges.push(contextEdge(aId, sId, type, "high", "overlay"));
+      };
+      for (const token of e.requires ?? []) link(token, "requires");
+      for (const token of e.produces ?? []) link(token, "produces");
+    }
+    return { nodes: [...nodes.values()], edges };
+  }
+};
+function applyOverlayRejections(edges, rootDir) {
+  const overlay = loadOverlay(rootDir);
+  const rejects = overlay?.reject ?? [];
+  if (rejects.length === 0) return edges;
+  const rejectKeys = new Set(
+    rejects.map((r) => `${actionId(r.action)}|${r.type}|${stateId(r.state)}`)
+  );
+  return edges.filter((e) => !rejectKeys.has(`${e.source}|${e.type}|${e.target}`));
+}
+
+// src/server/graph/core/context/registry.ts
+var ContextProviderRegistry = class {
+  constructor() {
+    this.providers = [];
+    this.ids = /* @__PURE__ */ new Set();
+  }
+  register(provider) {
+    if (this.ids.has(provider.id)) {
+      throw new Error(`Duplicate context provider id: ${provider.id}`);
+    }
+    this.ids.add(provider.id);
+    this.providers.push(provider);
+  }
+  getAll() {
+    return [...this.providers];
+  }
+};
+function registerBuiltins2(registry, disabled) {
+  const builtins = [nextjsPrismaContextProvider, overlayProvider];
+  for (const provider of builtins) {
+    if (disabled.has(provider.id)) continue;
+    registry.register(provider);
+  }
+}
+function loadCustomProviders(registry, config, rootDir, disabled) {
+  for (const entry of config.context?.providers ?? []) {
+    try {
+      const absPath = (0, import_node_path9.resolve)(rootDir, entry.path);
+      const mod = require(absPath);
+      const provider = "default" in mod ? mod.default : mod;
+      if (disabled.has(provider.id)) continue;
+      registry.register(provider);
+    } catch (err) {
+      process.stderr.write(`[launch-chart] failed to load custom context provider from ${entry.path}: ${err}
+`);
+    }
+  }
+}
+function createContextProviderRegistry(config, rootDir) {
+  const registry = new ContextProviderRegistry();
+  const disabled = new Set(config.context?.disabled ?? []);
+  registerBuiltins2(registry, disabled);
+  loadCustomProviders(registry, config, rootDir, disabled);
+  return registry;
+}
+
+// src/server/graph/core/context-map.ts
+function buildContextMap(layerOutputs, rootDir) {
+  const generated = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const config = loadConfig(rootDir);
+  const registry = createContextProviderRegistry(config, rootDir);
+  const nodesById = /* @__PURE__ */ new Map();
+  const edgesByKey = /* @__PURE__ */ new Map();
+  const providerStats = {};
+  const usedProviders = [];
+  for (const provider of registry.getAll()) {
+    let detected = false;
+    try {
+      detected = provider.detect(layerOutputs, rootDir);
+    } catch (e) {
+      process.stderr.write(`[launch-chart] context provider "${provider.id}" detect failed: ${e.message}
+`);
+      continue;
+    }
+    if (!detected) continue;
+    let contribution;
+    try {
+      contribution = provider.derive(layerOutputs, rootDir);
+    } catch (e) {
+      process.stderr.write(`[launch-chart] context provider "${provider.id}" derive failed: ${e.message}
+`);
+      continue;
+    }
+    usedProviders.push(provider.id);
+    providerStats[provider.id] = { nodes: contribution.nodes.length, edges: contribution.edges.length };
+    for (const node of contribution.nodes) {
+      if (!nodesById.has(node.id)) nodesById.set(node.id, node);
+    }
+    for (const edge of contribution.edges) {
+      const key = `${edge.source}|${edge.type}|${edge.target}`;
+      const existing = edgesByKey.get(key);
+      const edgeConf = edge.confidence ?? "low";
+      if (!existing) {
+        edgesByKey.set(key, { ...edge, providers: [provider.id] });
+      } else {
+        const existingConf = existing.confidence ?? "low";
+        existing.confidence = higherConfidence(existingConf, edgeConf);
+        const provs = existing.providers ?? [];
+        if (!provs.includes(provider.id)) provs.push(provider.id);
+        existing.providers = provs;
+      }
+    }
+  }
+  const merged = [...edgesByKey.values()];
+  const edges = applyOverlayRejections(merged, rootDir);
+  const rejectedCount = merged.length - edges.length;
+  const flagged = edges.map((e) => ({
+    source: e.source,
+    target: e.target,
+    type: e.type,
+    label: e.label ?? `${e.type}`,
+    confidence: e.confidence ?? "low"
+  }));
+  const nodes = [...nodesById.values()];
+  const stateCount = nodes.filter((n) => n.type === CONTEXT_NODE_STATE).length;
+  return {
+    metadata: {
+      generated,
+      scope: "derived",
+      layer: "context",
+      source: "context-map-builder",
+      derived: true,
+      providers: usedProviders,
+      provider_stats: providerStats,
+      action_count: nodes.length - stateCount,
+      state_count: stateCount,
+      candidate_edge_count: edges.length,
+      rejected_edge_count: rejectedCount,
+      note: "Edges are candidates (see flagged_edges + confidence) from the context providers. Promote via the curation overlay."
+    },
+    nodes,
+    edges,
+    cross_refs: [],
+    contradictions: [],
+    warnings: [],
+    flagged_edges: flagged
+  };
+}
+function writeContextMap(rootDir, output) {
+  const path2 = (0, import_node_path10.join)(rootDir, LAUNCHSECURE_DIR, "graphs", "context.json");
+  atomicWriteFileSync(path2, JSON.stringify(output, null, 2) + "\n");
+  return path2;
+}
+
+// src/server/graph/core/freshness.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path11 = require("node:path");
 init_launch_kit_paths();
 function exactFilenameRegex(name) {
   return new RegExp(`^${name.replace(/\./g, "\\.")}$`);
@@ -1934,7 +2222,7 @@ function isHardEscalation(relativePath) {
 var FreshnessTracker = class {
   constructor(rootDir) {
     this.dirty = false;
-    this.filePath = (0, import_node_path8.join)(rootDir, LAUNCHSECURE_DIR, "graphs", ".freshness.json");
+    this.filePath = (0, import_node_path11.join)(rootDir, LAUNCHSECURE_DIR, "graphs", ".freshness.json");
     this.snapshot = this.load() ?? {
       state: "fresh",
       lastFullRegenAt: null,
@@ -2021,9 +2309,9 @@ var FreshnessTracker = class {
     }
   }
   load() {
-    if (!(0, import_node_fs6.existsSync)(this.filePath)) return null;
+    if (!(0, import_node_fs7.existsSync)(this.filePath)) return null;
     try {
-      const parsed = JSON.parse((0, import_node_fs6.readFileSync)(this.filePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs7.readFileSync)(this.filePath, "utf-8"));
       if (parsed.schemaVersion !== SCHEMA_VERSION) return null;
       return {
         state: parsed.state,
@@ -2053,24 +2341,24 @@ function getFreshnessTracker(rootDir) {
 var GRAPHS_DIR2 = ".launchsecure/graphs";
 var NON_LAYER_GRAPH_FILES = /* @__PURE__ */ new Set(["tags.json", "effects-index.json"]);
 function getAvailableLayers(rootDir) {
-  const dir = (0, import_node_path9.join)(rootDir, GRAPHS_DIR2);
-  if (!(0, import_node_fs7.existsSync)(dir)) return [];
-  return (0, import_node_fs7.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".") && !NON_LAYER_GRAPH_FILES.has(f)).map((f) => f.replace(".json", ""));
+  const dir = (0, import_node_path12.join)(rootDir, GRAPHS_DIR2);
+  if (!(0, import_node_fs8.existsSync)(dir)) return [];
+  return (0, import_node_fs8.readdirSync)(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".") && !NON_LAYER_GRAPH_FILES.has(f)).map((f) => f.replace(".json", ""));
 }
 var graphCache = /* @__PURE__ */ new Map();
 var taggedCache = /* @__PURE__ */ new Map();
 function graphsDir(rootDir) {
-  return (0, import_node_path9.join)(rootDir, GRAPHS_DIR2);
+  return (0, import_node_path12.join)(rootDir, GRAPHS_DIR2);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path9.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path12.join)(graphsDir(rootDir), `${layer}.json`);
 }
 function tagsFilePath2(rootDir) {
-  return (0, import_node_path9.join)(graphsDir(rootDir), "tags.json");
+  return (0, import_node_path12.join)(graphsDir(rootDir), "tags.json");
 }
 function getMtimeMs(filePath) {
-  if (!(0, import_node_fs7.existsSync)(filePath)) return 0;
-  return (0, import_node_fs7.statSync)(filePath).mtimeMs;
+  if (!(0, import_node_fs8.existsSync)(filePath)) return 0;
+  return (0, import_node_fs8.statSync)(filePath).mtimeMs;
 }
 function invalidateCache(filePath) {
   graphCache.delete(filePath);
@@ -2109,20 +2397,20 @@ function applyTags(graph, layer, rootDir) {
 }
 function readGraphRaw(rootDir, layer) {
   const filePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs7.existsSync)(filePath)) return null;
-  const stat = (0, import_node_fs7.statSync)(filePath);
+  if (!(0, import_node_fs8.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs8.statSync)(filePath);
   const cached = graphCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.graph;
   }
-  const content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs8.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_fs7.existsSync)(rawFilePath)) return null;
+  if (!(0, import_node_fs8.existsSync)(rawFilePath)) return null;
   const rawMtime = getMtimeMs(rawFilePath);
   const tagsMtime = getMtimeMs(tagsFilePath2(rootDir));
   const cacheKey = `${rootDir}:${layer}`;
@@ -2146,7 +2434,7 @@ function readAllGraphs(rootDir) {
 }
 async function generateGraph(rootDir, layer) {
   const dir = graphsDir(rootDir);
-  (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
   const { results, failedFiles } = await runParseInWorker({ rootDir, layer });
   for (const result of results) {
     const filePath = graphFilePath(rootDir, result.layer);
@@ -2157,13 +2445,13 @@ async function generateGraph(rootDir, layer) {
   if (!layer) {
     const producedLayers = new Set(results.map((r) => r.layer));
     try {
-      for (const f of (0, import_node_fs7.readdirSync)(dir)) {
-        if (!f.endsWith(".json") || f === "tags.json" || f === "effects-index.json") continue;
+      for (const f of (0, import_node_fs8.readdirSync)(dir)) {
+        if (!f.endsWith(".json") || f === "tags.json" || f === "effects-index.json" || f === "context.json") continue;
         const layerName = f.replace(/\.json$/, "");
         if (producedLayers.has(layerName)) continue;
-        const orphan = (0, import_node_path9.join)(dir, f);
+        const orphan = (0, import_node_path12.join)(dir, f);
         try {
-          (0, import_node_fs7.unlinkSync)(orphan);
+          (0, import_node_fs8.unlinkSync)(orphan);
           invalidateCache(orphan);
           invalidateTaggedCache(rootDir, layerName);
           process.stderr.write(`[launch-chart] removed orphan layer file: ${f} (no parser produced ${layerName} this run)
@@ -2174,22 +2462,31 @@ async function generateGraph(rootDir, layer) {
     } catch {
     }
   }
-  try {
-    const allLayers = {};
-    for (const r of results) allLayers[r.layer] = r.output;
-    if (layer) {
-      for (const f of (0, import_node_fs7.readdirSync)(dir)) {
-        if (!f.endsWith(".json") || f === "tags.json" || f === "effects-index.json") continue;
-        const layerName = f.replace(/\.json$/, "");
-        if (allLayers[layerName]) continue;
-        const existing = readGraphRaw(rootDir, layerName);
-        if (existing) allLayers[layerName] = existing;
-      }
+  const allLayers = {};
+  for (const r of results) allLayers[r.layer] = r.output;
+  if (layer) {
+    for (const f of (0, import_node_fs8.readdirSync)(dir)) {
+      if (!f.endsWith(".json") || f.startsWith(".") || f === "tags.json" || f === "effects-index.json" || f === "context.json") continue;
+      const layerName = f.replace(/\.json$/, "");
+      if (allLayers[layerName]) continue;
+      const existing = readGraphRaw(rootDir, layerName);
+      if (existing) allLayers[layerName] = existing;
     }
+  }
+  try {
     const idx = buildEffectsIndex(allLayers);
     writeEffectsIndex(rootDir, idx);
   } catch (e) {
     process.stderr.write(`[launch-chart] effects-index build failed: ${e.message}
+`);
+  }
+  try {
+    const ctx = buildContextMap(allLayers, rootDir);
+    const ctxPath = writeContextMap(rootDir, ctx);
+    invalidateCache(ctxPath);
+    invalidateTaggedCache(rootDir, "context");
+  } catch (e) {
+    process.stderr.write(`[launch-chart] context-map build failed: ${e.message}
 `);
   }
   try {
@@ -2208,29 +2505,29 @@ async function generateGraph(rootDir, layer) {
 
 // src/server/lockfile.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs8 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_os = require("node:os");
-var import_node_path10 = require("node:path");
+var import_node_path13 = require("node:path");
 init_launch_kit_paths();
 function lockDir(projectRoot) {
   if (projectRoot) {
-    return (0, import_node_path10.join)(projectRoot, LAUNCHSECURE_DIR);
+    return (0, import_node_path13.join)(projectRoot, LAUNCHSECURE_DIR);
   }
-  return (0, import_node_path10.join)((0, import_node_os.homedir)(), LAUNCHSECURE_DIR);
+  return (0, import_node_path13.join)((0, import_node_os.homedir)(), LAUNCHSECURE_DIR);
 }
 function lockPath(projectRoot) {
-  return (0, import_node_path10.join)(lockDir(projectRoot), "launch-chart.lock");
+  return (0, import_node_path13.join)(lockDir(projectRoot), "launch-chart.lock");
 }
 var _activeProjectRoot;
 function readLock(projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
   const p = lockPath(root);
-  if (!(0, import_node_fs8.existsSync)(p)) {
+  if (!(0, import_node_fs9.existsSync)(p)) {
     if (root) {
       const globalP = lockPath();
-      if ((0, import_node_fs8.existsSync)(globalP)) {
+      if ((0, import_node_fs9.existsSync)(globalP)) {
         try {
-          const data = JSON.parse((0, import_node_fs8.readFileSync)(globalP, "utf-8"));
+          const data = JSON.parse((0, import_node_fs9.readFileSync)(globalP, "utf-8"));
           if (typeof data.pid === "number" && typeof data.port === "number" && data.cwd === root) {
             return data;
           }
@@ -2241,7 +2538,7 @@ function readLock(projectRoot) {
     return null;
   }
   try {
-    const data = JSON.parse((0, import_node_fs8.readFileSync)(p, "utf-8"));
+    const data = JSON.parse((0, import_node_fs9.readFileSync)(p, "utf-8"));
     if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
     return data;
   } catch {
@@ -2278,7 +2575,7 @@ function getLiveLock(projectRoot) {
   const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
   if (!live) {
     try {
-      (0, import_node_fs8.unlinkSync)(lockPath(root));
+      (0, import_node_fs9.unlinkSync)(lockPath(root));
     } catch {
     }
     return null;
@@ -2287,14 +2584,14 @@ function getLiveLock(projectRoot) {
 }
 function writeLock(data, projectRoot) {
   const root = projectRoot ?? _activeProjectRoot;
-  (0, import_node_fs8.mkdirSync)(lockDir(root), { recursive: true });
-  (0, import_node_fs8.writeFileSync)(lockPath(root), JSON.stringify(data, null, 2) + "\n", "utf-8");
+  (0, import_node_fs9.mkdirSync)(lockDir(root), { recursive: true });
+  (0, import_node_fs9.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_fs8.unlinkSync)(lockPath(root));
+    (0, import_node_fs9.unlinkSync)(lockPath(root));
   } catch {
   }
 }
@@ -2303,20 +2600,20 @@ function clearLock(projectRoot) {
 init_config();
 
 // src/server/graph/core/parser-registry.ts
-var import_node_path21 = require("node:path");
+var import_node_path24 = require("node:path");
 
 // src/server/graph/parsers/ts/typescript-project.ts
-var import_node_fs12 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path17 = require("node:path");
 init_config();
 
 // src/server/graph/core/resolve-paths.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path15 = require("node:path");
 
 // src/server/graph/core/walk.ts
-var import_node_fs9 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path14 = require("node:path");
 var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -2326,12 +2623,12 @@ var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
 ]);
 function walk(dir, exts) {
   const results = [];
-  if (!(0, import_node_fs9.existsSync)(dir)) return results;
-  for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true })) {
-    const full = (0, import_node_path11.join)(dir, entry.name);
+  if (!(0, import_node_fs10.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path14.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path11.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path14.extname)(entry.name))) {
       results.push(full);
     }
   }
@@ -2339,15 +2636,15 @@ function walk(dir, exts) {
 }
 function walkWithIgnore(dir, exts, opts = {}) {
   const results = [];
-  if (!(0, import_node_fs9.existsSync)(dir)) return results;
+  if (!(0, import_node_fs10.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_fs9.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".")) continue;
       if (skip.has(entry.name)) continue;
-      results.push(...walkWithIgnore((0, import_node_path11.join)(dir, entry.name), exts, opts));
-    } else if (exts.includes((0, import_node_path11.extname)(entry.name))) {
-      results.push((0, import_node_path11.join)(dir, entry.name));
+      results.push(...walkWithIgnore((0, import_node_path14.join)(dir, entry.name), exts, opts));
+    } else if (exts.includes((0, import_node_path14.extname)(entry.name))) {
+      results.push((0, import_node_path14.join)(dir, entry.name));
     }
   }
   return results;
@@ -2355,9 +2652,9 @@ function walkWithIgnore(dir, exts, opts = {}) {
 
 // src/server/graph/core/resolve-paths.ts
 function hasSqlFiles(dir) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return false;
+  if (!(0, import_node_fs11.existsSync)(dir)) return false;
   try {
-    return (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true }).some(
+    return (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true }).some(
       (e) => e.isFile() && e.name.endsWith(".sql")
     );
   } catch {
@@ -2365,27 +2662,27 @@ function hasSqlFiles(dir) {
   }
 }
 function hasNestedMigrationSql(dir) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return false;
+  if (!(0, import_node_fs11.existsSync)(dir)) return false;
   try {
-    return (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true }).some(
-      (e) => e.isDirectory() && (0, import_node_fs10.existsSync)((0, import_node_path12.join)(dir, e.name, "migration.sql"))
+    return (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isDirectory() && (0, import_node_fs11.existsSync)((0, import_node_path15.join)(dir, e.name, "migration.sql"))
     );
   } catch {
     return false;
   }
 }
 function resolveDbFromDir(dir) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
-  const schemaPath = (0, import_node_path12.join)(dir, "schema.prisma");
-  if ((0, import_node_fs10.existsSync)(schemaPath)) {
-    const migrationsDir2 = (0, import_node_path12.join)(dir, "migrations");
+  if (!(0, import_node_fs11.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
+  const schemaPath = (0, import_node_path15.join)(dir, "schema.prisma");
+  if ((0, import_node_fs11.existsSync)(schemaPath)) {
+    const migrationsDir2 = (0, import_node_path15.join)(dir, "migrations");
     return {
       kind: "prisma",
       schemaPath,
-      migrationsDir: (0, import_node_fs10.existsSync)(migrationsDir2) ? migrationsDir2 : null
+      migrationsDir: (0, import_node_fs11.existsSync)(migrationsDir2) ? migrationsDir2 : null
     };
   }
-  const migrationsDir = (0, import_node_path12.join)(dir, "migrations");
+  const migrationsDir = (0, import_node_path15.join)(dir, "migrations");
   if (hasSqlFiles(migrationsDir) || hasNestedMigrationSql(migrationsDir)) {
     return { kind: "sql-migrations", migrationsDir, schemaPath: null };
   }
@@ -2396,19 +2693,19 @@ function resolveDbFromDir(dir) {
 }
 function detectDbConfig(rootDir, config) {
   if (config.paths?.dbDir) {
-    return resolveDbFromDir((0, import_node_path12.join)(rootDir, config.paths.dbDir));
+    return resolveDbFromDir((0, import_node_path15.join)(rootDir, config.paths.dbDir));
   }
-  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path12.join)("db", "migrations"), "migrations"];
+  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path15.join)("db", "migrations"), "migrations"];
   for (const c of candidates) {
-    const dir = (0, import_node_path12.join)(rootDir, c);
+    const dir = (0, import_node_path15.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_path12.join)(rootDir, config.paths.dbDir);
-  if (dbConfig.kind === "prisma") return (0, import_node_path12.dirname)(dbConfig.schemaPath);
+  if (config.paths?.dbDir) return (0, import_node_path15.join)(rootDir, config.paths.dbDir);
+  if (dbConfig.kind === "prisma") return (0, import_node_path15.dirname)(dbConfig.schemaPath);
   if (dbConfig.kind === "sql-migrations") return dbConfig.migrationsDir;
   return null;
 }
@@ -2439,16 +2736,16 @@ var NON_SOURCE_DIRS = /* @__PURE__ */ new Set([
   "libs"
 ]);
 function dirHasTSFiles(dir) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return false;
+  if (!(0, import_node_fs11.existsSync)(dir)) return false;
   try {
     const stack = [dir];
     while (stack.length > 0) {
       const cur = stack.pop();
-      const entries = (0, import_node_fs10.readdirSync)(cur, { withFileTypes: true });
+      const entries = (0, import_node_fs11.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_path12.join)(cur, e.name));
+          stack.push((0, import_node_path15.join)(cur, e.name));
         }
       }
     }
@@ -2457,15 +2754,15 @@ function dirHasTSFiles(dir) {
   return false;
 }
 function collectCodeBearingChildren(dir, extraSkip) {
-  if (!(0, import_node_fs10.existsSync)(dir)) return [];
+  if (!(0, import_node_fs11.existsSync)(dir)) return [];
   const out = [];
   try {
-    for (const entry of (0, import_node_fs10.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs11.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_path12.join)(dir, entry.name);
+      const full = (0, import_node_path15.join)(dir, entry.name);
       if (dirHasTSFiles(full)) out.push(full);
     }
   } catch {
@@ -2477,7 +2774,7 @@ function detectSrcRoots(rootDir, srcDir, appDir, config) {
     const roots2 = /* @__PURE__ */ new Set();
     roots2.add(appDir);
     for (const r of config.paths.srcRoots) {
-      const abs = (0, import_node_path12.isAbsolute)(r) ? r : (0, import_node_path12.resolve)(rootDir, r);
+      const abs = (0, import_node_path15.isAbsolute)(r) ? r : (0, import_node_path15.resolve)(rootDir, r);
       roots2.add(abs);
     }
     return [...roots2];
@@ -2486,7 +2783,7 @@ function detectSrcRoots(rootDir, srcDir, appDir, config) {
   roots.add(appDir);
   for (const c of collectCodeBearingChildren(srcDir)) roots.add(c);
   if (srcDir !== rootDir) {
-    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path12.basename)(srcDir)]);
+    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path15.basename)(srcDir)]);
     for (const c of collectCodeBearingChildren(rootDir, skipSrcWrapper)) roots.add(c);
   }
   return [...roots];
@@ -2498,10 +2795,10 @@ function detectConventionFiles(rootDir, srcDir) {
   const dirs = srcDir === rootDir ? [rootDir] : [srcDir, rootDir];
   for (const dir of dirs) {
     for (const name of CONVENTION_NAMES) {
-      const full = (0, import_node_path12.join)(dir, name);
-      if (!seen.has(full) && (0, import_node_fs10.existsSync)(full)) {
+      const full = (0, import_node_path15.join)(dir, name);
+      if (!seen.has(full) && (0, import_node_fs11.existsSync)(full)) {
         try {
-          if ((0, import_node_fs10.statSync)(full).isFile()) {
+          if ((0, import_node_fs11.statSync)(full).isFile()) {
             seen.add(full);
             out.push(full);
           }
@@ -2516,22 +2813,22 @@ function resolveProjectPaths(rootDir, config) {
   let srcDir;
   let appDir;
   if (config.paths?.appDir) {
-    appDir = (0, import_node_path12.join)(rootDir, config.paths.appDir);
-    srcDir = config.paths.srcDir ? (0, import_node_path12.join)(rootDir, config.paths.srcDir) : (0, import_node_path12.dirname)(appDir);
+    appDir = (0, import_node_path15.join)(rootDir, config.paths.appDir);
+    srcDir = config.paths.srcDir ? (0, import_node_path15.join)(rootDir, config.paths.srcDir) : (0, import_node_path15.dirname)(appDir);
   } else {
-    const srcApp = (0, import_node_path12.join)(rootDir, "src", "app");
-    const rootApp = (0, import_node_path12.join)(rootDir, "app");
-    if ((0, import_node_fs10.existsSync)(srcApp)) {
-      srcDir = (0, import_node_path12.join)(rootDir, "src");
+    const srcApp = (0, import_node_path15.join)(rootDir, "src", "app");
+    const rootApp = (0, import_node_path15.join)(rootDir, "app");
+    if ((0, import_node_fs11.existsSync)(srcApp)) {
+      srcDir = (0, import_node_path15.join)(rootDir, "src");
       appDir = srcApp;
-    } else if ((0, import_node_fs10.existsSync)(rootApp)) {
+    } else if ((0, import_node_fs11.existsSync)(rootApp)) {
       srcDir = rootDir;
       appDir = rootApp;
     } else {
       return null;
     }
   }
-  const apiDir = (0, import_node_path12.join)(appDir, "api");
+  const apiDir = (0, import_node_path15.join)(appDir, "api");
   const dbConfig = detectDbConfig(rootDir, config);
   const dbDir = detectDbDir(rootDir, config, dbConfig);
   const srcRoots = detectSrcRoots(rootDir, srcDir, appDir, config);
@@ -2558,25 +2855,25 @@ var CLASSIFICATION_TO_LAYER = {
   external: "ui"
 };
 function toNodeId(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path14.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path17.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path14.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path17.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
 function resolveImport(srcDir, specifier) {
   if (!specifier.startsWith("@/")) return null;
   const rel = specifier.slice(2);
-  const base = (0, import_node_path14.join)(srcDir, rel);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path14.join)(base, "index.ts"), (0, import_node_path14.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs12.existsSync)(c) && (0, import_node_fs12.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path17.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path17.join)(base, "index.ts"), (0, import_node_path17.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs13.existsSync)(c) && (0, import_node_fs13.statSync)(c).isFile()) return c;
   }
   return null;
 }
 function resolveRelativeImport(fromFile, specifier) {
-  const base = (0, import_node_path14.join)((0, import_node_path14.dirname)(fromFile), specifier);
-  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path14.join)(base, "index.ts"), (0, import_node_path14.join)(base, "index.tsx")]) {
-    if ((0, import_node_fs12.existsSync)(c) && (0, import_node_fs12.statSync)(c).isFile()) return c;
+  const base = (0, import_node_path17.join)((0, import_node_path17.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path17.join)(base, "index.ts"), (0, import_node_path17.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs13.existsSync)(c) && (0, import_node_fs13.statSync)(c).isFile()) return c;
   }
   return null;
 }
@@ -2597,7 +2894,7 @@ function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
     const resolved = resolveRelativeImport(barrelAbsPath, re.from);
     if (!resolved) continue;
     if (re.isWildcard) {
-      const targetBn = (0, import_node_path14.basename)(resolved);
+      const targetBn = (0, import_node_path17.basename)(resolved);
       const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
       if (targetIsBarrel) {
         const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
@@ -2624,12 +2921,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_path14.basename)(absPath);
+    const bn = (0, import_node_path17.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_path14.relative)(srcDir, (0, import_node_path14.dirname)(absPath)).replace(/\\/g, "/");
+      const barrelId = (0, import_node_path17.relative)(srcDir, (0, import_node_path17.dirname)(absPath)).replace(/\\/g, "/");
       barrels.set(barrelId, map);
     }
   }
@@ -2654,10 +2951,10 @@ function extractRoute(id) {
   return route || "/";
 }
 function nameFromFilename(absPath) {
-  return (0, import_node_path14.basename)(absPath, (0, import_node_path14.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+  return (0, import_node_path17.basename)(absPath, (0, import_node_path17.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
 function filePathToAppRoute(appDir, absPath) {
-  let route = ("/" + (0, import_node_path14.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
+  let route = ("/" + (0, import_node_path17.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
   route = route.replace(/\/\([^)]+\)/g, "");
   route = route.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "*$1?");
   route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
@@ -2905,7 +3202,7 @@ function generate(rootDir) {
   const apiNodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const routeToNodeId = /* @__PURE__ */ new Map();
-  const fileSet = allDiscovered.filter((f) => !(0, import_node_path14.basename)(f).startsWith("index."));
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path17.basename)(f).startsWith("index."));
   for (const absPath of fileSet) {
     const id = toNodeId(srcDir, rootDir, absPath);
     const type = classifyType(absPath, id);
@@ -3065,7 +3362,7 @@ function generate(rootDir) {
     } catch {
       continue;
     }
-    const externalId = (0, import_node_path14.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const externalId = (0, import_node_path17.relative)(rootDir, absPath).replace(/\\/g, "/");
     const edgesFromThis = [];
     const seen = /* @__PURE__ */ new Set();
     for (const imp of parsed.imports) {
@@ -3415,7 +3712,7 @@ var typescriptProjectParser = {
 };
 
 // src/server/graph/parsers/db/prisma-schema.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 init_config();
 function parseModels(content) {
   const nodes = [];
@@ -3508,7 +3805,7 @@ function parseEnums(content) {
 }
 function detect2(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs13.existsSync)(paths.dbConfig.schemaPath);
+  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs14.existsSync)(paths.dbConfig.schemaPath);
 }
 function generate2(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
@@ -3525,7 +3822,7 @@ function generate2(rootDir) {
     };
   }
   const schemaPath = paths.dbConfig.schemaPath;
-  const content = (0, import_node_fs13.readFileSync)(schemaPath, "utf-8");
+  const content = (0, import_node_fs14.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -3582,8 +3879,8 @@ var prismaSchemaParser = {
 };
 
 // src/server/graph/parsers/db/sql-migrations.ts
-var import_node_fs14 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path18 = require("node:path");
 var import_pgsql_parser = require("pgsql-parser");
 init_config();
 var PG_TO_PRISMA = {
@@ -3617,15 +3914,15 @@ function pgTypeToPrisma(pgType) {
   return PG_TO_PRISMA[upper] ?? upper;
 }
 function discoverMigrationFiles(migrationsDir) {
-  if (!(0, import_node_fs14.existsSync)(migrationsDir)) return [];
+  if (!(0, import_node_fs15.existsSync)(migrationsDir)) return [];
   const out = [];
-  const entries = (0, import_node_fs14.readdirSync)(migrationsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = (0, import_node_fs15.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_path15.join)(migrationsDir, entry.name, "migration.sql");
-      if ((0, import_node_fs14.existsSync)(sqlPath)) out.push(sqlPath);
+      const sqlPath = (0, import_node_path18.join)(migrationsDir, entry.name, "migration.sql");
+      if ((0, import_node_fs15.existsSync)(sqlPath)) out.push(sqlPath);
     } else if (entry.isFile() && entry.name.endsWith(".sql")) {
-      out.push((0, import_node_path15.join)(migrationsDir, entry.name));
+      out.push((0, import_node_path18.join)(migrationsDir, entry.name));
     }
   }
   return out;
@@ -3670,7 +3967,7 @@ function parseMigrations(migrationsDir, dialect = postgresDialect) {
   };
   if (!migrationsDir) return state;
   for (const sqlPath of discoverMigrationFiles(migrationsDir)) {
-    const sql = (0, import_node_fs14.readFileSync)(sqlPath, "utf-8");
+    const sql = (0, import_node_fs15.readFileSync)(sqlPath, "utf-8");
     let ast;
     try {
       ast = dialect.parse(sql);
@@ -4239,8 +4536,8 @@ function indexIsPrismaUncoverable(idx) {
   return idx.hasPredicate || idx.hasExpressions || idx.method !== "btree";
 }
 function loadPrismaState(schemaPath) {
-  if (!schemaPath || !(0, import_node_fs14.existsSync)(schemaPath)) return null;
-  const content = (0, import_node_fs14.readFileSync)(schemaPath, "utf-8");
+  if (!schemaPath || !(0, import_node_fs15.existsSync)(schemaPath)) return null;
+  const content = (0, import_node_fs15.readFileSync)(schemaPath, "utf-8");
   const tables = /* @__PURE__ */ new Map();
   const enums = /* @__PURE__ */ new Map();
   const relations = [];
@@ -4647,7 +4944,7 @@ function generate3(rootDir) {
   const migrationFiles = migrationsDir ? discoverMigrationFiles(migrationsDir) : [];
   let migrationNodeCount = 0;
   for (const sqlPath of migrationFiles) {
-    const sql = (0, import_node_fs14.readFileSync)(sqlPath, "utf-8");
+    const sql = (0, import_node_fs15.readFileSync)(sqlPath, "utf-8");
     const name = deriveMigrationName(sqlPath);
     let ast;
     try {
@@ -4965,14 +5262,14 @@ var fetchResolverParser = {
 };
 
 // src/server/graph/parsers/crosslayer/api-annotations.ts
-var import_node_fs15 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs16 = require("node:fs");
+var import_node_path19 = require("node:path");
 init_config();
 var API_ANNOTATION_RE = /@api\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\/\S+)/g;
 function toNodeId2(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path16.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path19.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path16.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path19.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -5017,7 +5314,7 @@ var apiAnnotationsParser = {
     const flaggedEdges = [];
     const seenEdge = /* @__PURE__ */ new Set();
     for (const absPath of files) {
-      const content = (0, import_node_fs15.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs16.readFileSync)(absPath, "utf-8");
       const sourceId = toNodeId2(srcDir, rootDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
       let match;
@@ -5061,14 +5358,14 @@ var apiAnnotationsParser = {
 };
 
 // src/server/graph/parsers/crosslayer/url-literal-scanner.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_path20 = require("node:path");
 init_config();
 var URL_LITERAL_RE = /['"`](\/[a-zA-Z][^'"`\s]*?)['"`]/g;
 function toNodeId3(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path17.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path20.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path17.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path20.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -5112,7 +5409,7 @@ var urlLiteralScannerParser = {
     for (const absPath of files) {
       const sourceId = toNodeId3(srcDir, rootDir, absPath);
       if (!uiNodeIds.has(sourceId)) continue;
-      const content = (0, import_node_fs16.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs17.readFileSync)(absPath, "utf-8");
       let match;
       URL_LITERAL_RE.lastIndex = 0;
       while ((match = URL_LITERAL_RE.exec(content)) !== null) {
@@ -5143,8 +5440,8 @@ var urlLiteralScannerParser = {
 };
 
 // src/server/graph/parsers/static/static-values.ts
-var import_node_fs17 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path21 = require("node:path");
 init_config();
 var parseCode = null;
 function tryLoadTreeSitter() {
@@ -5181,21 +5478,21 @@ function extractEnumValues(rootDir) {
   const schemaPaths = [];
   if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath) {
     schemaPaths.push(paths.dbConfig.schemaPath);
-    schemaPaths.push((0, import_node_path18.join)((0, import_node_path18.dirname)(paths.dbConfig.schemaPath), "schema"));
+    schemaPaths.push((0, import_node_path21.join)((0, import_node_path21.dirname)(paths.dbConfig.schemaPath), "schema"));
   } else {
-    schemaPaths.push((0, import_node_path18.join)(rootDir, "prisma", "schema.prisma"));
-    schemaPaths.push((0, import_node_path18.join)(rootDir, "prisma", "schema"));
+    schemaPaths.push((0, import_node_path21.join)(rootDir, "prisma", "schema.prisma"));
+    schemaPaths.push((0, import_node_path21.join)(rootDir, "prisma", "schema"));
   }
   let content = "";
   for (const p of schemaPaths) {
-    if ((0, import_node_fs17.existsSync)(p)) {
+    if ((0, import_node_fs18.existsSync)(p)) {
       try {
-        const stat = (0, import_node_fs17.statSync)(p);
+        const stat = (0, import_node_fs18.statSync)(p);
         if (stat.isFile()) {
-          content = (0, import_node_fs17.readFileSync)(p, "utf-8");
+          content = (0, import_node_fs18.readFileSync)(p, "utf-8");
         } else if (stat.isDirectory()) {
-          const files = (0, import_node_fs17.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
-          content = files.map((f) => (0, import_node_fs17.readFileSync)((0, import_node_path18.join)(p, f), "utf-8")).join("\n");
+          const files = (0, import_node_fs18.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
+          content = files.map((f) => (0, import_node_fs18.readFileSync)((0, import_node_path21.join)(p, f), "utf-8")).join("\n");
         }
       } catch {
         continue;
@@ -5353,27 +5650,27 @@ function extractSeedData(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
   const candidates = [];
   if (paths?.dbDir) {
-    candidates.push((0, import_node_path18.join)(paths.dbDir, "seed.ts"));
-    candidates.push((0, import_node_path18.join)(paths.dbDir, "seed.js"));
+    candidates.push((0, import_node_path21.join)(paths.dbDir, "seed.ts"));
+    candidates.push((0, import_node_path21.join)(paths.dbDir, "seed.js"));
   } else {
-    candidates.push((0, import_node_path18.join)(rootDir, "prisma", "seed.ts"));
-    candidates.push((0, import_node_path18.join)(rootDir, "prisma", "seed.js"));
+    candidates.push((0, import_node_path21.join)(rootDir, "prisma", "seed.ts"));
+    candidates.push((0, import_node_path21.join)(rootDir, "prisma", "seed.js"));
   }
-  const baseRoots = paths?.srcRoots ?? [(0, import_node_path18.join)(rootDir, "src")];
+  const baseRoots = paths?.srcRoots ?? [(0, import_node_path21.join)(rootDir, "src")];
   for (const root of baseRoots) {
-    candidates.push((0, import_node_path18.join)(root, "server", "lib", "system-tags.ts"));
+    candidates.push((0, import_node_path21.join)(root, "server", "lib", "system-tags.ts"));
   }
   const seedFiles = candidates.filter((p) => {
     try {
-      return (0, import_node_fs17.existsSync)(p) && (0, import_node_fs17.statSync)(p).isFile();
+      return (0, import_node_fs18.existsSync)(p) && (0, import_node_fs18.statSync)(p).isFile();
     } catch {
       return false;
     }
   });
   const useTreeSitter = tryLoadTreeSitter();
   for (const filePath of seedFiles) {
-    const content = (0, import_node_fs17.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path18.relative)(rootDir, filePath);
+    const content = (0, import_node_fs18.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path21.relative)(rootDir, filePath);
     const seeded = detectSeededArrays(content, relPath);
     let astRoot = null;
     if (useTreeSitter && parseCode) {
@@ -5467,11 +5764,11 @@ function extractSeedData(rootDir) {
   return { nodes, edges };
 }
 function walkDir(dir, exts) {
-  if (!(0, import_node_fs17.existsSync)(dir)) return [];
+  if (!(0, import_node_fs18.existsSync)(dir)) return [];
   const results = [];
-  for (const entry of (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
-    const full = (0, import_node_path18.join)(dir, entry.name);
+    const full = (0, import_node_path21.join)(dir, entry.name);
     if (entry.isDirectory()) results.push(...walkDir(full, exts));
     else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(full);
   }
@@ -5480,7 +5777,7 @@ function walkDir(dir, exts) {
 function extractConstants(rootDir) {
   const nodes = [];
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  const roots = paths?.srcRoots ?? [(0, import_node_path18.join)(rootDir, "src")];
+  const roots = paths?.srcRoots ?? [(0, import_node_path21.join)(rootDir, "src")];
   const seenFile = /* @__PURE__ */ new Set();
   const allFiles = [];
   for (const root of roots) {
@@ -5493,8 +5790,8 @@ function extractConstants(rootDir) {
   }
   if (allFiles.length === 0) return { nodes };
   for (const filePath of allFiles) {
-    const content = (0, import_node_fs17.readFileSync)(filePath, "utf-8");
-    const relPath = (0, import_node_path18.relative)(rootDir, filePath);
+    const content = (0, import_node_fs18.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path21.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) {
@@ -5528,13 +5825,13 @@ function extractConstants(rootDir) {
 }
 function detect4(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
-  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath && (0, import_node_fs17.existsSync)(paths.dbConfig.schemaPath)) {
+  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath && (0, import_node_fs18.existsSync)(paths.dbConfig.schemaPath)) {
     return true;
   }
   if (paths?.dbDir) {
-    if ((0, import_node_fs17.existsSync)((0, import_node_path18.join)(paths.dbDir, "seed.ts")) || (0, import_node_fs17.existsSync)((0, import_node_path18.join)(paths.dbDir, "seed.js"))) return true;
+    if ((0, import_node_fs18.existsSync)((0, import_node_path21.join)(paths.dbDir, "seed.ts")) || (0, import_node_fs18.existsSync)((0, import_node_path21.join)(paths.dbDir, "seed.js"))) return true;
   }
-  return (0, import_node_fs17.existsSync)((0, import_node_path18.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs17.existsSync)((0, import_node_path18.join)(rootDir, "prisma", "seed.ts"));
+  return (0, import_node_fs18.existsSync)((0, import_node_path21.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs18.existsSync)((0, import_node_path21.join)(rootDir, "prisma", "seed.ts"));
 }
 function generate4(rootDir) {
   const enumResult = extractEnumValues(rootDir);
@@ -5609,8 +5906,8 @@ var staticValuesParser = {
 };
 
 // src/server/graph/parsers/crosslayer/static-ref-scanner.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path19 = require("node:path");
+var import_node_fs19 = require("node:fs");
+var import_node_path22 = require("node:path");
 init_config();
 var MIN_VALUE_LENGTH = 4;
 var SKIP_VALUES = /* @__PURE__ */ new Set([
@@ -5785,11 +6082,11 @@ var staticRefScannerParser = {
     const seen = /* @__PURE__ */ new Set();
     let filesScanned = 0;
     for (const absPath of files) {
-      const relFromSrc = (0, import_node_path19.relative)(srcDir, absPath).replace(/\\/g, "/");
-      const sourceId = relFromSrc.startsWith("..") ? (0, import_node_path19.relative)(rootDir, absPath).replace(/\\/g, "/") : relFromSrc;
+      const relFromSrc = (0, import_node_path22.relative)(srcDir, absPath).replace(/\\/g, "/");
+      const sourceId = relFromSrc.startsWith("..") ? (0, import_node_path22.relative)(rootDir, absPath).replace(/\\/g, "/") : relFromSrc;
       const sourceLayer = uiNodeIds.has(sourceId) ? "ui" : apiNodeIds.has(sourceId) ? "api" : null;
       if (!sourceLayer) continue;
-      const content = (0, import_node_fs18.readFileSync)(absPath, "utf-8");
+      const content = (0, import_node_fs19.readFileSync)(absPath, "utf-8");
       filesScanned++;
       let fileRefs;
       if (parseCode2) {
@@ -5831,13 +6128,13 @@ var staticRefScannerParser = {
 };
 
 // src/server/graph/parsers/crosslayer/middleware-gates.ts
-var import_node_path20 = require("node:path");
+var import_node_path23 = require("node:path");
 init_ts_extractor();
 init_config();
 function toNodeId4(srcDir, rootDir, absPath) {
-  const relFromSrc = (0, import_node_path20.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path23.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path20.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path23.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -6118,7 +6415,7 @@ var ParserRegistry = class {
     return all;
   }
 };
-function registerBuiltins2(registry, disabled) {
+function registerBuiltins3(registry, disabled) {
   const builtins = [
     typescriptProjectParser,
     prismaSchemaParser,
@@ -6139,7 +6436,7 @@ function registerBuiltins2(registry, disabled) {
 function loadCustomParsers(registry, config, rootDir, disabled) {
   for (const entry of config.parsers?.custom ?? []) {
     try {
-      const absPath = (0, import_node_path21.resolve)(rootDir, entry.path);
+      const absPath = (0, import_node_path24.resolve)(rootDir, entry.path);
       const mod = require(absPath);
       const parser = "default" in mod ? mod.default : mod;
       if (disabled.has(parser.id)) continue;
@@ -6162,19 +6459,19 @@ function loadCustomParsers(registry, config, rootDir, disabled) {
 function createRegistry(config, rootDir) {
   const registry = new ParserRegistry();
   const disabled = new Set(config.parsers?.disabled ?? []);
-  registerBuiltins2(registry, disabled);
+  registerBuiltins3(registry, disabled);
   loadCustomParsers(registry, config, rootDir, disabled);
   return registry;
 }
 
 // src/server/graph/core/audit-core.ts
-var import_node_fs20 = require("node:fs");
-var import_node_path23 = require("node:path");
+var import_node_fs21 = require("node:fs");
+var import_node_path26 = require("node:path");
 init_launch_kit_paths();
 
 // src/server/graph/core/audit-security.ts
-var import_node_fs19 = require("node:fs");
-var import_node_path22 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path25 = require("node:path");
 init_ts_extractor();
 init_config();
 function collectSourceFiles(rootDir) {
@@ -6199,9 +6496,9 @@ function collectSourceFiles(rootDir) {
   return out;
 }
 function toNodeId5(rootDir, srcDir, absPath) {
-  const relFromSrc = (0, import_node_path22.relative)(srcDir, absPath).replace(/\\/g, "/");
+  const relFromSrc = (0, import_node_path25.relative)(srcDir, absPath).replace(/\\/g, "/");
   if (relFromSrc.startsWith("..")) {
-    return (0, import_node_path22.relative)(rootDir, absPath).replace(/\\/g, "/");
+    return (0, import_node_path25.relative)(rootDir, absPath).replace(/\\/g, "/");
   }
   return relFromSrc;
 }
@@ -6311,18 +6608,18 @@ function collectDeclaredEnvKeys(rootDir) {
   const files = [];
   let entries = [];
   try {
-    entries = (0, import_node_fs19.readdirSync)(rootDir);
+    entries = (0, import_node_fs20.readdirSync)(rootDir);
   } catch {
     return { keys, files };
   }
   for (const name of entries) {
     if (!name.startsWith(".env")) continue;
-    const abs = (0, import_node_path22.join)(rootDir, name);
-    if (!(0, import_node_fs19.existsSync)(abs)) continue;
+    const abs = (0, import_node_path25.join)(rootDir, name);
+    if (!(0, import_node_fs20.existsSync)(abs)) continue;
     files.push(name);
     let content = "";
     try {
-      content = (0, import_node_fs19.readFileSync)(abs, "utf-8");
+      content = (0, import_node_fs20.readFileSync)(abs, "utf-8");
     } catch {
       continue;
     }
@@ -6509,10 +6806,10 @@ function checkHardcodedUrlFallback(rootDir, core) {
 
 // src/server/graph/core/audit-core.ts
 function readGraphFile(rootDir, layer) {
-  const filePath = (0, import_node_path23.join)(rootDir, LAUNCHSECURE_DIR, "graphs", `${layer}.json`);
-  if (!(0, import_node_fs20.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path26.join)(rootDir, LAUNCHSECURE_DIR, "graphs", `${layer}.json`);
+  if (!(0, import_node_fs21.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs20.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs21.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -6554,15 +6851,15 @@ function checkUnprotectedRoutes(rootDir) {
   const findings = [];
   const api = readGraphFile(rootDir, "api");
   if (!api) return buildSkipped("api", "unprotected_routes", "no api graph");
-  const routePermsPath = (0, import_node_path23.join)(rootDir, "src", "config", "route-permissions.ts");
-  if (!(0, import_node_fs20.existsSync)(routePermsPath)) {
+  const routePermsPath = (0, import_node_path26.join)(rootDir, "src", "config", "route-permissions.ts");
+  if (!(0, import_node_fs21.existsSync)(routePermsPath)) {
     return buildSkipped(
       "api",
       "unprotected_routes",
       `no src/config/route-permissions.ts \u2014 this check needs a centralized ROUTE_PERMISSIONS inventory to compare endpoints against`
     );
   }
-  const routePermsContent = (0, import_node_fs20.readFileSync)(routePermsPath, "utf-8");
+  const routePermsContent = (0, import_node_fs21.readFileSync)(routePermsPath, "utf-8");
   const registeredRoutes = /* @__PURE__ */ new Set();
   const routeEntryRe = /path:\s*'([^']+)'/g;
   let rm;
@@ -6647,15 +6944,15 @@ function checkUnenforcedPermissions(rootDir) {
       `no seed_permission nodes \u2014 this project either has no seed permissions or hasn't tagged them in seed.ts`
     );
   }
-  const routePermsPath = (0, import_node_path23.join)(rootDir, "src", "config", "route-permissions.ts");
-  if (!(0, import_node_fs20.existsSync)(routePermsPath)) {
+  const routePermsPath = (0, import_node_path26.join)(rootDir, "src", "config", "route-permissions.ts");
+  if (!(0, import_node_fs21.existsSync)(routePermsPath)) {
     return buildSkipped(
       "static",
       "unenforced_permissions",
       `no src/config/route-permissions.ts to compare seed permissions against`
     );
   }
-  const routePermsContent = (0, import_node_fs20.readFileSync)(routePermsPath, "utf-8");
+  const routePermsContent = (0, import_node_fs21.readFileSync)(routePermsPath, "utf-8");
   for (const perm of permissions) {
     const regex = new RegExp(`permission:\\s*['"]${perm.key}['"]`);
     if (!regex.test(routePermsContent)) {
@@ -6691,9 +6988,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_path23.join)(rootDir, "src", node.id);
-    if (!(0, import_node_fs20.existsSync)(filePath)) continue;
-    const content = (0, import_node_fs20.readFileSync)(filePath, "utf-8");
+    const filePath = (0, import_node_path26.join)(rootDir, "src", node.id);
+    if (!(0, import_node_fs21.existsSync)(filePath)) continue;
+    const content = (0, import_node_fs21.readFileSync)(filePath, "utf-8");
     let m;
     allCapsRe.lastIndex = 0;
     while ((m = allCapsRe.exec(content)) !== null) {
@@ -6853,16 +7150,16 @@ var MIME_TYPES = {
 function findProjectRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
-    const graphsDir2 = import_node_path24.default.join(dir, LAUNCHSECURE_DIR, "graphs");
-    if (import_node_fs21.default.existsSync(import_node_path24.default.join(graphsDir2, "ui.json")) || import_node_fs21.default.existsSync(import_node_path24.default.join(graphsDir2, "api.json")) || import_node_fs21.default.existsSync(import_node_path24.default.join(graphsDir2, "db.json"))) return dir;
-    const parent = import_node_path24.default.dirname(dir);
+    const graphsDir2 = import_node_path27.default.join(dir, LAUNCHSECURE_DIR, "graphs");
+    if (import_node_fs22.default.existsSync(import_node_path27.default.join(graphsDir2, "ui.json")) || import_node_fs22.default.existsSync(import_node_path27.default.join(graphsDir2, "api.json")) || import_node_fs22.default.existsSync(import_node_path27.default.join(graphsDir2, "db.json"))) return dir;
+    const parent = import_node_path27.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = startDir;
   for (let i = 0; i < 8; i++) {
-    if (import_node_fs21.default.existsSync(import_node_path24.default.join(dir, ".git"))) return dir;
-    const parent = import_node_path24.default.dirname(dir);
+    if (import_node_fs22.default.existsSync(import_node_path27.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path27.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6871,7 +7168,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_path24.default.resolve(monorepoRoot, projectParam);
+  const resolved = import_node_path27.default.resolve(monorepoRoot, projectParam);
   if (!resolved.startsWith(monorepoRoot)) {
     throw new Error("Project path outside monorepo root");
   }
@@ -6922,16 +7219,16 @@ async function buildMergedGraph(root) {
   };
 }
 function serveStatic(res, filePath) {
-  if (!import_node_fs21.default.existsSync(filePath) || !import_node_fs21.default.statSync(filePath).isFile()) return false;
-  const ext = import_node_path24.default.extname(filePath).toLowerCase();
+  if (!import_node_fs22.default.existsSync(filePath) || !import_node_fs22.default.statSync(filePath).isFile()) return false;
+  const ext = import_node_path27.default.extname(filePath).toLowerCase();
   const mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
-  import_node_fs21.default.createReadStream(filePath).pipe(res);
+  import_node_fs22.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function serveIndex(res, clientDir) {
-  const indexPath = import_node_path24.default.join(clientDir, "index.html");
-  if (!import_node_fs21.default.existsSync(indexPath)) {
+  const indexPath = import_node_path27.default.join(clientDir, "index.html");
+  if (!import_node_fs22.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;
@@ -6939,14 +7236,14 @@ function serveIndex(res, clientDir) {
   serveStatic(res, indexPath);
 }
 function tryListen(server, port) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve4(port);
+      resolve5(port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -6983,7 +7280,7 @@ async function startChartServer(opts = {}) {
     }
     return { port: existing.port, url: existing.url };
   }
-  const clientDir = opts.clientDir ?? import_node_path24.default.join(__dirname, "..", "chart-client");
+  const clientDir = opts.clientDir ?? import_node_path27.default.join(__dirname, "..", "chart-client");
   const rootConfig = loadConfig(projectRoot);
   const projects = rootConfig.projects ?? [];
   const server = import_node_http.default.createServer((req, res) => {
@@ -6999,11 +7296,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_path24.default.resolve(projectRoot, p.root);
-          const hasGraphs = import_node_fs21.default.existsSync(import_node_path24.default.join(absRoot, LAUNCHSECURE_DIR, "graphs"));
-          const hasNextConfig = import_node_fs21.default.existsSync(import_node_path24.default.join(absRoot, "next.config.ts")) || import_node_fs21.default.existsSync(import_node_path24.default.join(absRoot, "next.config.js")) || import_node_fs21.default.existsSync(import_node_path24.default.join(absRoot, "next.config.mjs"));
+          const absRoot = import_node_path27.default.resolve(projectRoot, p.root);
+          const hasGraphs = import_node_fs22.default.existsSync(import_node_path27.default.join(absRoot, LAUNCHSECURE_DIR, "graphs"));
+          const hasNextConfig = import_node_fs22.default.existsSync(import_node_path27.default.join(absRoot, "next.config.ts")) || import_node_fs22.default.existsSync(import_node_path27.default.join(absRoot, "next.config.js")) || import_node_fs22.default.existsSync(import_node_path27.default.join(absRoot, "next.config.mjs"));
           return { name: p.name, root: p.root, hasGraphs, hasNextConfig };
-        }) : [{ name: import_node_path24.default.basename(projectRoot), root: ".", hasGraphs: import_node_fs21.default.existsSync(import_node_path24.default.join(projectRoot, LAUNCHSECURE_DIR, "graphs")), hasNextConfig: true }];
+        }) : [{ name: import_node_path27.default.basename(projectRoot), root: ".", hasGraphs: import_node_fs22.default.existsSync(import_node_path27.default.join(projectRoot, LAUNCHSECURE_DIR, "graphs")), hasNextConfig: true }];
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ projects: projectList, monorepoRoot: projectRoot }));
         return;
@@ -7049,20 +7346,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_path24.default.isAbsolute(relPath)) {
+        if (!relPath || relPath.includes("..") || import_node_path27.default.isAbsolute(relPath)) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "Invalid path" }));
           return;
         }
-        const filePath = import_node_path24.default.join(reqRoot, relPath);
-        if (!filePath.startsWith(reqRoot) || !import_node_fs21.default.existsSync(filePath) || !import_node_fs21.default.statSync(filePath).isFile()) {
+        const filePath = import_node_path27.default.join(reqRoot, relPath);
+        if (!filePath.startsWith(reqRoot) || !import_node_fs22.default.existsSync(filePath) || !import_node_fs22.default.statSync(filePath).isFile()) {
           res.writeHead(404, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "File not found" }));
           return;
         }
-        const ext = import_node_path24.default.extname(filePath).toLowerCase();
+        const ext = import_node_path27.default.extname(filePath).toLowerCase();
         const langMap = { ".ts": "typescript", ".tsx": "tsx", ".js": "javascript", ".jsx": "jsx", ".prisma": "prisma", ".json": "json", ".css": "css" };
-        const content = import_node_fs21.default.readFileSync(filePath, "utf-8");
+        const content = import_node_fs22.default.readFileSync(filePath, "utf-8");
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ content, language: langMap[ext] ?? "text", path: relPath }));
         return;
@@ -7117,8 +7414,8 @@ async function startChartServer(opts = {}) {
             const newConfig = JSON.parse(body);
             const existingConfig = loadConfig(reqRoot);
             const merged = { ...existingConfig, ...newConfig };
-            const configPath = import_node_path24.default.join(reqRoot, LAUNCHCHART_CONFIG_FILE);
-            import_node_fs21.default.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+            const configPath = import_node_path27.default.join(reqRoot, LAUNCHCHART_CONFIG_FILE);
+            import_node_fs22.default.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ ok: true }));
           } catch (err) {
@@ -7151,8 +7448,8 @@ async function startChartServer(opts = {}) {
             const taggerConfig = JSON.parse(body);
             const config2 = loadConfig(reqRoot);
             config2.taggers = taggerConfig;
-            const configPath = import_node_path24.default.join(reqRoot, LAUNCHCHART_CONFIG_FILE);
-            import_node_fs21.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+            const configPath = import_node_path27.default.join(reqRoot, LAUNCHCHART_CONFIG_FILE);
+            import_node_fs22.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) {
@@ -7222,7 +7519,7 @@ async function startChartServer(opts = {}) {
           dbDir: !!config2.paths?.dbDir,
           srcRoots: !!(config2.paths?.srcRoots && config2.paths.srcRoots.length > 0)
         };
-        const relFromRoot = (abs) => import_node_path24.default.relative(reqRoot, abs) || ".";
+        const relFromRoot = (abs) => import_node_path27.default.relative(reqRoot, abs) || ".";
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({
           projectRoot: reqRoot,
@@ -7244,19 +7541,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_path24.default.resolve(browsePath);
-        const twoUp = import_node_path24.default.resolve(projectRoot, "..", "..");
+        const abs = import_node_path27.default.resolve(browsePath);
+        const twoUp = import_node_path27.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_fs21.default.readdirSync(abs, { withFileTypes: true });
+          const entries = import_node_fs22.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_path24.default.dirname(abs) : null;
+          const parent = abs !== twoUp ? import_node_path27.default.dirname(abs) : null;
           res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ current: abs, parent, dirs, relative: import_node_path24.default.relative(projectRoot, abs) || "." }));
+          res.end(JSON.stringify({ current: abs, parent, dirs, relative: import_node_path27.default.relative(projectRoot, abs) || "." }));
         } catch (err) {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ ok: false, error: String(err) }));
@@ -7282,8 +7579,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_path24.default.join(projectRoot, LAUNCHCHART_CONFIG_FILE);
-            import_node_fs21.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+            const configPath = import_node_path27.default.join(projectRoot, LAUNCHCHART_CONFIG_FILE);
+            import_node_fs22.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" });
@@ -7296,7 +7593,7 @@ async function startChartServer(opts = {}) {
         return;
       }
       if (url2.pathname !== "/") {
-        const staticPath = import_node_path24.default.join(clientDir, url2.pathname);
+        const staticPath = import_node_path27.default.join(clientDir, url2.pathname);
         if (serveStatic(res, staticPath)) return;
       }
       serveIndex(res, clientDir);