@launchsecure/launch-kit 0.0.26 → 0.0.27

package/dist/server/parse-worker-entry.js

@@ -0,0 +1,4721 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/launch-kit-paths.ts
+var LAUNCHSECURE_DIR, LAUNCHCHART_CONFIG_FILE;
+var init_launch_kit_paths = __esm({
+  "src/server/launch-kit-paths.ts"() {
+    "use strict";
+    LAUNCHSECURE_DIR = ".launchsecure";
+    LAUNCHCHART_CONFIG_FILE = ".launchchart.json";
+  }
+});
+
+// src/server/graph/core/parse-failure-cache.ts
+function hashContent(content) {
+  return "sha256:" + (0, import_node_crypto.createHash)("sha256").update(content).digest("hex");
+}
+function setActiveFailureCache(cache) {
+  activeCache = cache;
+}
+function getActiveFailureCache() {
+  return activeCache;
+}
+var import_node_crypto, import_node_fs4, import_node_path4, SCHEMA_VERSION, ParseFailureCache, activeCache;
+var init_parse_failure_cache = __esm({
+  "src/server/graph/core/parse-failure-cache.ts"() {
+    "use strict";
+    import_node_crypto = require("node:crypto");
+    import_node_fs4 = require("node:fs");
+    import_node_path4 = require("node:path");
+    init_launch_kit_paths();
+    SCHEMA_VERSION = 1;
+    ParseFailureCache = class {
+      constructor(rootDir, treeSitterFingerprint) {
+        this.failures = /* @__PURE__ */ new Map();
+        this.dirty = false;
+        this.cacheFilePath = (0, import_node_path4.join)(rootDir, LAUNCHSECURE_DIR, "graphs", ".failures.json");
+        this.fingerprint = treeSitterFingerprint;
+        this.load();
+      }
+      /** Path the cache persists to. Exposed so tier 3 can audit it. */
+      get filePath() {
+        return this.cacheFilePath;
+      }
+      /**
+       * Return the entry for absPath IF the cached entry's contentHash matches the
+       * current bytes. Otherwise null (caller should attempt a real parse).
+       */
+      shouldSkip(absPath, content) {
+        const cached = this.failures.get(absPath);
+        if (!cached) return null;
+        if (cached.contentHash !== hashContent(content)) return null;
+        return cached;
+      }
+      /** Record a parse failure. Increments consecutiveAttempts when hash matches. */
+      recordFailure(absPath, content, error) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const hash = hashContent(content);
+        const prior = this.failures.get(absPath);
+        const entry = {
+          contentHash: hash,
+          failedAt: prior && prior.contentHash === hash ? prior.failedAt : now,
+          lastAttemptAt: now,
+          lastError: error,
+          consecutiveAttempts: prior && prior.contentHash === hash ? prior.consecutiveAttempts + 1 : 1
+        };
+        this.failures.set(absPath, entry);
+        this.dirty = true;
+      }
+      /** Bump the lastAttemptAt timestamp on a skip without changing the failure record. */
+      bumpAttempt(absPath) {
+        const cached = this.failures.get(absPath);
+        if (!cached) return;
+        cached.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.dirty = true;
+      }
+      /** Clear a single entry (call on successful parse). */
+      clear(absPath) {
+        if (!this.failures.has(absPath)) return false;
+        this.failures.delete(absPath);
+        this.dirty = true;
+        return true;
+      }
+      /** Wipe the entire cache (call after a successful tier-3 full regen). */
+      clearAll() {
+        if (this.failures.size === 0) return;
+        this.failures.clear();
+        this.dirty = true;
+      }
+      /** Snapshot for meta/status surfacing. */
+      list() {
+        const out = [];
+        for (const [path, entry] of this.failures) out.push({ path, ...entry });
+        return out;
+      }
+      size() {
+        return this.failures.size;
+      }
+      /**
+       * Atomically persist to disk. No-op if nothing has changed since last flush.
+       * Uses temp + rename so a torn write never corrupts the cache.
+       */
+      flush() {
+        if (!this.dirty) return;
+        const payload = {
+          schemaVersion: SCHEMA_VERSION,
+          treeSitterFingerprint: this.fingerprint,
+          failures: Object.fromEntries(this.failures)
+        };
+        const dir = (0, import_node_path4.dirname)(this.cacheFilePath);
+        const tmp = this.cacheFilePath + ".tmp";
+        try {
+          require("node:fs").mkdirSync(dir, { recursive: true });
+          (0, import_node_fs4.writeFileSync)(tmp, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+          (0, import_node_fs4.renameSync)(tmp, this.cacheFilePath);
+          this.dirty = false;
+        } catch (e) {
+          process.stderr.write(`[lc-failure-cache] flush failed for ${this.cacheFilePath}: ${e.message}
+`);
+        }
+      }
+      load() {
+        if (!(0, import_node_fs4.existsSync)(this.cacheFilePath)) return;
+        let parsed;
+        try {
+          parsed = JSON.parse((0, import_node_fs4.readFileSync)(this.cacheFilePath, "utf-8"));
+        } catch (e) {
+          process.stderr.write(`[lc-failure-cache] cache file unreadable, starting fresh: ${e.message}
+`);
+          return;
+        }
+        if (!parsed || parsed.schemaVersion !== SCHEMA_VERSION) {
+          process.stderr.write(`[lc-failure-cache] schema version mismatch, discarding cache
+`);
+          return;
+        }
+        if (parsed.treeSitterFingerprint !== this.fingerprint) {
+          process.stderr.write(`[lc-failure-cache] tree-sitter fingerprint changed, retrying all cached failures
+`);
+          return;
+        }
+        for (const [path, entry] of Object.entries(parsed.failures)) {
+          this.failures.set(path, entry);
+        }
+      }
+    };
+    activeCache = null;
+  }
+});
+
+// src/server/graph/core/ts-extractor.ts
+var ts_extractor_exports = {};
+__export(ts_extractor_exports, {
+  ParseCascadeError: () => ParseCascadeError,
+  classifyFile: () => classifyFile,
+  classifyRouteAgainstMiddleware: () => classifyRouteAgainstMiddleware,
+  createQuery: () => createQuery,
+  extractAuthWrappersTS: () => extractAuthWrappersTS,
+  extractDbCallsTS: () => extractDbCallsTS,
+  extractDeep: () => extractDeep,
+  extractEffects: () => extractEffects,
+  extractMiddlewareAuthTS: () => extractMiddlewareAuthTS,
+  getTreeSitterFingerprint: () => getTreeSitterFingerprint,
+  initTreeSitter: () => initTreeSitter,
+  middlewarePatternToRegex: () => middlewarePatternToRegex,
+  parseCodeTS: () => parseCodeTS,
+  parseFileTS: () => parseFileTS,
+  parseSource: () => parseSource,
+  setExtractorConfig: () => setExtractorConfig
+});
+async function initTreeSitter() {
+  if (initialized) return;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    const TreeSitter = require("web-tree-sitter");
+    await TreeSitter.init();
+    const wasmPath = require.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
+    tsxLanguage = await TreeSitter.Language.load(wasmPath);
+    TreeSitterCtor = TreeSitter;
+    parserInstance = new TreeSitterCtor();
+    parserInstance.setLanguage(tsxLanguage);
+    initialized = true;
+  })();
+  return initPromise;
+}
+function ensureInit() {
+  if (!initialized || !tsxLanguage || !parserInstance) {
+    throw new Error("Tree-sitter not initialized. Call initTreeSitter() first.");
+  }
+}
+function getTreeSitterFingerprint() {
+  const read = (pkg) => {
+    try {
+      return String(require(`${pkg}/package.json`).version ?? "unknown");
+    } catch {
+      return "unknown";
+    }
+  };
+  return `web-tree-sitter@${read("web-tree-sitter")}+tree-sitter-typescript@${read("tree-sitter-typescript")}`;
+}
+function getQuery(name) {
+  ensureInit();
+  const cached = queryCache.get(name);
+  if (cached) return cached;
+  const scmPath = (0, import_node_path5.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs5.readFileSync)(scmPath, "utf-8");
+  const query = tsxLanguage.query(scm);
+  queryCache.set(name, query);
+  return query;
+}
+function recreateParser() {
+  if (!TreeSitterCtor || !tsxLanguage) {
+    throw new Error("recreateParser() called before initTreeSitter()");
+  }
+  try {
+    parserInstance?.delete?.();
+  } catch {
+  }
+  parserInstance = new TreeSitterCtor();
+  parserInstance.setLanguage(tsxLanguage);
+}
+function parseSource(absPath) {
+  ensureInit();
+  let content;
+  try {
+    const stat = (0, import_node_fs5.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_fs5.readFileSync)(absPath, "utf-8");
+  } catch (e) {
+    process.stderr.write(`[lc-extractor] read failed for ${absPath}: ${e instanceof Error ? e.message : String(e)}
+`);
+    return null;
+  }
+  const cache = getActiveFailureCache();
+  if (cache) {
+    const skipEntry = cache.shouldSkip(absPath, content);
+    if (skipEntry) {
+      cache.bumpAttempt(absPath);
+      process.stderr.write(`[lc-extractor] skipping ${absPath}: known-bad (${skipEntry.consecutiveAttempts} attempts, last error: ${skipEntry.lastError})
+`);
+      return null;
+    }
+  }
+  try {
+    const tree = parserInstance.parse(content);
+    consecutiveParseFailures = 0;
+    cache?.clear(absPath);
+    return tree;
+  } catch (e) {
+    consecutiveParseFailures++;
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(
+      `[lc-extractor] parse failed for ${absPath}: ${msg} (consecutive failures: ${consecutiveParseFailures}/${MAX_CONSECUTIVE_PARSE_FAILURES})
+`
+    );
+    cache?.recordFailure(absPath, content, msg);
+    try {
+      recreateParser();
+    } catch (recreateErr) {
+      const rmsg = recreateErr instanceof Error ? recreateErr.message : String(recreateErr);
+      process.stderr.write(`[lc-extractor] FATAL: recreateParser failed after ${absPath}: ${rmsg}
+`);
+      consecutiveParseFailures = 0;
+      throw recreateErr;
+    }
+    if (consecutiveParseFailures >= MAX_CONSECUTIVE_PARSE_FAILURES) {
+      const tripCount = consecutiveParseFailures;
+      consecutiveParseFailures = 0;
+      throw new ParseCascadeError(absPath, tripCount);
+    }
+    return null;
+  }
+}
+function parseCodeTS(code) {
+  ensureInit();
+  return parserInstance.parse(code);
+}
+function createQuery(pattern) {
+  ensureInit();
+  return tsxLanguage.query(pattern);
+}
+function setExtractorConfig(config) {
+  extraDbIdentifiers = config.dbIdentifiers ?? [];
+  extraMutationMethods = config.mutationMethods ?? [];
+}
+function getMutationMethods() {
+  return /* @__PURE__ */ new Set([...PRISMA_MUTATION_METHODS_BUILTIN, ...extraMutationMethods]);
+}
+function getFallbackDbIdentifiers() {
+  return /* @__PURE__ */ new Set([...DB_IDENTIFIERS_FALLBACK, ...extraDbIdentifiers]);
+}
+function looksLikeUrl(s) {
+  return s.startsWith("/") || /^(https?:)?\/\//i.test(s);
+}
+function templateStartsWithSlash(text) {
+  const content = text.slice(1);
+  return content.startsWith("/");
+}
+function captureMap(match) {
+  const map = {};
+  for (const c of match.captures) {
+    map[c.name] = c.node.text;
+  }
+  return map;
+}
+function childrenOfType(node, type) {
+  return node.children.filter((n) => n.type === type);
+}
+function childOfType(node, type) {
+  return node.children.find((n) => n.type === type);
+}
+function emptyParsedFile(absPath) {
+  return {
+    name: absPath.split("/").pop() ?? absPath,
+    exports: [],
+    imports: [],
+    reExports: [],
+    jsxElements: /* @__PURE__ */ new Set(),
+    navigations: [],
+    fetchCalls: []
+  };
+}
+function parseFileTS(absPath) {
+  const tree = parseSource(absPath);
+  if (!tree) return emptyParsedFile(absPath);
+  const root = tree.rootNode;
+  const imports = [];
+  const importStatements = childrenOfType(root, "import_statement");
+  for (const stmt of importStatements) {
+    const sourceNode = childOfType(stmt, "string");
+    const frag = sourceNode ? childOfType(sourceNode, "string_fragment") : void 0;
+    if (!frag) continue;
+    const specifier = frag.text;
+    const hasTypeKeyword = stmt.children.some(
+      (n) => n.type === "type" && n.text === "type"
+    );
+    const clause = childOfType(stmt, "import_clause");
+    if (!clause) {
+      imports.push({ names: [], specifier, isTypeOnly: false, typeNames: /* @__PURE__ */ new Set() });
+      continue;
+    }
+    const names = [];
+    const typeNames = /* @__PURE__ */ new Set();
+    const defaultId = childOfType(clause, "identifier");
+    if (defaultId) names.push(defaultId.text);
+    const nsImport = childOfType(clause, "namespace_import");
+    if (nsImport) {
+      const nsId = childOfType(nsImport, "identifier");
+      if (nsId) names.push(nsId.text);
+    }
+    const namedImports = childOfType(clause, "named_imports");
+    if (namedImports) {
+      for (const spec of childrenOfType(namedImports, "import_specifier")) {
+        const identifiers = childrenOfType(spec, "identifier");
+        const importedName = identifiers.length > 1 ? identifiers[identifiers.length - 1].text : identifiers[0]?.text;
+        if (importedName) {
+          names.push(importedName);
+          const specIsType = spec.children.some(
+            (n) => n.type === "type" && n.text === "type"
+          );
+          if (specIsType) typeNames.add(importedName);
+        }
+      }
+    }
+    if (names.length > 0 || hasTypeKeyword) {
+      imports.push({ names, specifier, isTypeOnly: hasTypeKeyword, typeNames });
+    }
+  }
+  const importQuery = getQuery("imports");
+  const importMatches = importQuery.matches(root);
+  for (const m of importMatches) {
+    const caps = captureMap(m);
+    if (caps["import.dynamic"]) {
+      imports.push({
+        names: [],
+        specifier: caps["import.dynamic"],
+        isTypeOnly: false,
+        typeNames: /* @__PURE__ */ new Set()
+      });
+    }
+  }
+  const exportsSet = /* @__PURE__ */ new Set();
+  const exportsOrdered = [];
+  let defaultName = null;
+  let firstValueExport = null;
+  let firstTypeExport = null;
+  function addExport(name2, kind) {
+    if (!exportsSet.has(name2)) {
+      exportsSet.add(name2);
+      exportsOrdered.push(name2);
+    }
+    if (kind === "default") defaultName = name2;
+    else if (kind === "value" && !firstValueExport) firstValueExport = name2;
+    else if (kind === "type" && !firstTypeExport) firstTypeExport = name2;
+  }
+  const exportQuery = getQuery("exports");
+  const exportMatches = exportQuery.matches(root);
+  for (const m of exportMatches) {
+    const caps = captureMap(m);
+    if (caps["export.default.func"]) addExport(caps["export.default.func"], "default");
+    else if (caps["export.default.class"]) addExport(caps["export.default.class"], "default");
+    else if (caps["export.default.value"]) addExport(caps["export.default.value"], "default");
+    else if (caps["export.named.func"]) addExport(caps["export.named.func"], "value");
+    else if (caps["export.named.class"]) addExport(caps["export.named.class"], "value");
+    else if (caps["export.named.const"]) addExport(caps["export.named.const"], "value");
+    else if (caps["export.named.enum"]) addExport(caps["export.named.enum"], "value");
+    else if (caps["export.named.type"]) addExport(caps["export.named.type"], "type");
+    else if (caps["export.named.interface"]) addExport(caps["export.named.interface"], "type");
+    else if (caps["export.bare.name"]) addExport(caps["export.bare.name"], "value");
+    if (caps["reexport.name"]) addExport(caps["reexport.name"], "value");
+  }
+  for (const stmt of childrenOfType(root, "export_statement")) {
+    const hasDefault = stmt.children.some((n) => n.text === "default");
+    if (hasDefault && !defaultName) {
+      defaultName = "default";
+    }
+  }
+  const reExports = [];
+  for (const m of exportMatches) {
+    const caps = captureMap(m);
+    if (caps["reexport.name"] && caps["reexport.source"]) {
+      reExports.push({ name: caps["reexport.name"], from: caps["reexport.source"] });
+    }
+    if (caps["reexport.wildcard.source"]) {
+      reExports.push({ name: "*", from: caps["reexport.wildcard.source"], isWildcard: true });
+    }
+  }
+  const jsxElements = /* @__PURE__ */ new Set();
+  const jsxQuery = getQuery("jsx-elements");
+  const jsxCaptures = jsxQuery.captures(root);
+  for (const c of jsxCaptures) {
+    if (c.name === "jsx.tag") {
+      if (/^[A-Z]/.test(c.node.text)) {
+        jsxElements.add(c.node.text);
+      }
+    } else if (c.name === "jsx.member_tag") {
+      const rootName = c.node.text.split(".")[0];
+      if (rootName && /^[A-Z]/.test(rootName)) {
+        jsxElements.add(rootName);
+      }
+    }
+  }
+  const navigations = [];
+  const navQuery = getQuery("navigations");
+  const navMatches = navQuery.matches(root);
+  for (const m of navMatches) {
+    const caps = captureMap(m);
+    if (caps["nav.target.literal"] && caps["nav.method"]) {
+      navigations.push({
+        kind: caps["nav.method"] === "push" ? "router-push" : "router-replace",
+        target: caps["nav.target.literal"],
+        isTemplate: false
+      });
+    }
+    if (caps["nav.target.template"] && caps["nav.method.template"]) {
+      navigations.push({
+        kind: caps["nav.method.template"] === "push" ? "router-push" : "router-replace",
+        target: caps["nav.target.template"],
+        isTemplate: true
+      });
+    }
+    const linkLiteral = caps["nav.link.literal"] || caps["nav.link.literal.self"];
+    if (linkLiteral) {
+      navigations.push({ kind: "link-href", target: linkLiteral, isTemplate: false });
+    }
+    const linkTemplate = caps["nav.link.template"] || caps["nav.link.template.self"];
+    if (linkTemplate) {
+      navigations.push({ kind: "link-href", target: linkTemplate, isTemplate: true });
+    }
+    if (caps["nav.redirect.literal"]) {
+      navigations.push({ kind: "router-replace", target: caps["nav.redirect.literal"], isTemplate: false });
+    }
+    if (caps["nav.redirect.template"]) {
+      navigations.push({ kind: "router-replace", target: caps["nav.redirect.template"], isTemplate: true });
+    }
+    if (caps["nav.window.literal"]) {
+      navigations.push({ kind: "window-location", target: caps["nav.window.literal"], isTemplate: false });
+    }
+    if (caps["nav.window.assign.target"]) {
+      navigations.push({ kind: "window-location", target: caps["nav.window.assign.target"], isTemplate: false });
+    }
+  }
+  const fetchCalls = [];
+  const fetchQuery = getQuery("fetch-calls");
+  const fetchMatches = fetchQuery.matches(root);
+  for (const m of fetchMatches) {
+    const caps = captureMap(m);
+    if (caps["fetch.url.literal"] && looksLikeUrl(caps["fetch.url.literal"])) {
+      fetchCalls.push({ url: caps["fetch.url.literal"], isTemplate: false, kind: "fetch" });
+    }
+    if (caps["fetch.url.template"] && templateStartsWithSlash(caps["fetch.url.template"])) {
+      fetchCalls.push({ url: caps["fetch.url.template"], isTemplate: true, kind: "fetch" });
+    }
+    const clientUrl = caps["fetch.client.url.literal"] || caps["fetch.await.url.literal"];
+    const clientMethod = caps["fetch.method"] || caps["fetch.await.method"];
+    if (clientUrl && clientMethod && looksLikeUrl(clientUrl)) {
+      fetchCalls.push({
+        method: clientMethod.toUpperCase(),
+        url: clientUrl,
+        isTemplate: false,
+        kind: "client-method"
+      });
+    }
+    const clientUrlTpl = caps["fetch.client.url.template"] || caps["fetch.await.url.template"];
+    const clientMethodTpl = caps["fetch.method.template"] || caps["fetch.await.method.template"];
+    if (clientUrlTpl && clientMethodTpl && templateStartsWithSlash(clientUrlTpl)) {
+      fetchCalls.push({
+        method: clientMethodTpl.toUpperCase(),
+        url: clientUrlTpl,
+        isTemplate: true,
+        kind: "client-method"
+      });
+    }
+  }
+  const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
+  return { name, exports: exportsOrdered, imports, reExports, jsxElements, navigations, fetchCalls };
+}
+function extractDbCallsTS(absPath) {
+  const tree = parseSource(absPath);
+  if (!tree) return [];
+  const root = tree.rootNode;
+  const dbQuery = getQuery("db-calls");
+  const matches = dbQuery.matches(root);
+  const dbIdentifiers = /* @__PURE__ */ new Set();
+  for (const stmt of childrenOfType(root, "import_statement")) {
+    const sourceNode = childOfType(stmt, "string");
+    const frag = sourceNode ? childOfType(sourceNode, "string_fragment") : void 0;
+    if (!frag) continue;
+    const spec = frag.text;
+    if (spec.includes("prisma") || spec.includes("/db") || spec === "@prisma/client") {
+      const clause = childOfType(stmt, "import_clause");
+      if (clause) {
+        const defaultId = childOfType(clause, "identifier");
+        if (defaultId) dbIdentifiers.add(defaultId.text);
+        const named = childOfType(clause, "named_imports");
+        if (named) {
+          for (const specNode of childrenOfType(named, "import_specifier")) {
+            const ids = childrenOfType(specNode, "identifier");
+            const importedName = ids[ids.length - 1];
+            if (importedName) dbIdentifiers.add(importedName.text);
+          }
+        }
+      }
+    }
+  }
+  if (dbIdentifiers.size === 0) {
+    for (const id of getFallbackDbIdentifiers()) dbIdentifiers.add(id);
+  } else {
+    for (const id of extraDbIdentifiers) dbIdentifiers.add(id);
+  }
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    const caps = captureMap(m);
+    const sbTable = caps["sb.table"];
+    const sbMethod = caps["sb.method"];
+    if (sbTable && sbMethod) {
+      const key2 = `sql:${sbTable}.${sbMethod}`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      const isMutation = SUPABASE_MUTATION_METHODS_BUILTIN.has(sbMethod) || extraMutationMethods.includes(sbMethod);
+      calls.push({ model: sbTable, method: sbMethod, isMutation, kind: "sql" });
+      continue;
+    }
+    const identifier = caps["db.identifier"];
+    const model = caps["db.model"];
+    const method = caps["db.method"];
+    if (!identifier || !model || !method) continue;
+    if (!dbIdentifiers.has(identifier)) continue;
+    const key = `orm:${model}.${method}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    calls.push({ model, method, isMutation: getMutationMethods().has(method), kind: "orm" });
+  }
+  return calls;
+}
+function classifyFile(absPath) {
+  const fileName = require("path").basename(absPath);
+  if (fileName.includes(".test.") || fileName.includes(".spec.") || fileName.includes("__test")) return "test";
+  if (fileName.includes(".stories.")) return "story";
+  if (fileName === "middleware.ts" || fileName === "middleware.tsx") return "middleware";
+  const tree = parseSource(absPath);
+  if (!tree) return "util";
+  const root = tree.rootNode;
+  const classifyQuery = getQuery("classify");
+  const captures = classifyQuery.captures(root);
+  const capNames = new Set(captures.map((c) => c.name));
+  if (capNames.has("http_export") || capNames.has("http_export_fn")) return "endpoint";
+  if (capNames.has("use_server_directive") && fileName !== "page.tsx" && fileName !== "layout.tsx") {
+    return "server-action";
+  }
+  if (fileName === "page.tsx" && capNames.has("has_jsx")) return "page";
+  if (fileName === "layout.tsx" && capNames.has("has_jsx")) return "layout";
+  if (capNames.has("has_create_context") || capNames.has("has_create_context_bare")) return "context";
+  if (capNames.has("has_jsx")) return "component";
+  if (capNames.has("hook_decl") || capNames.has("hook_const")) return "hook";
+  if (fileName.includes("config") || fileName.includes(".config.")) return "config";
+  return "lib";
+}
+function extractAuthWrappersTS(absPath) {
+  const tree = parseSource(absPath);
+  if (!tree) return /* @__PURE__ */ new Set();
+  const root = tree.rootNode;
+  const wrapperQuery = getQuery("wrappers");
+  const matches = wrapperQuery.matches(root);
+  const wrappers = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    const caps = captureMap(m);
+    if (caps["wrapper.fn_name"]) {
+      wrappers.add(caps["wrapper.fn_name"]);
+    }
+  }
+  const inlineHelpers = /* @__PURE__ */ new Set();
+  for (const stmt of childrenOfType(root, "import_statement")) {
+    const sourceNode = childOfType(stmt, "string");
+    const frag = sourceNode ? childOfType(sourceNode, "string_fragment") : void 0;
+    if (!frag) continue;
+    const provider = INLINE_AUTH_IMPORTS.find((p) => p.module.test(frag.text));
+    if (!provider) continue;
+    const clause = childOfType(stmt, "import_clause");
+    if (!clause) continue;
+    const named = childOfType(clause, "named_imports");
+    if (!named) continue;
+    for (const specNode of childrenOfType(named, "import_specifier")) {
+      const ids = childrenOfType(specNode, "identifier");
+      const importedName = ids[0]?.text;
+      const localName = ids[ids.length - 1]?.text;
+      if (importedName && provider.helpers.includes(importedName) && localName) {
+        inlineHelpers.add(localName);
+      }
+    }
+  }
+  if (inlineHelpers.size > 0) {
+    const text = root.text;
+    for (const name of inlineHelpers) {
+      const re = new RegExp(`\\b${name}\\s*\\(`);
+      if (re.test(text)) {
+        wrappers.add("inline");
+        break;
+      }
+    }
+  }
+  return wrappers;
+}
+function inferIntentFromName(name) {
+  if (TRUST_AS_PROTECT_KEYS.has(name)) {
+    return { intent: "protect", hint: `Next.js config.${name} \u2014 paths matched run through middleware` };
+  }
+  for (const re of EXEMPT_NAME_PATTERNS) {
+    if (re.test(name)) return { intent: "exempt", hint: `name "${name}" matches /${re.source}/` };
+  }
+  for (const re of PROTECT_NAME_PATTERNS) {
+    if (re.test(name)) return { intent: "protect", hint: `name "${name}" matches /${re.source}/` };
+  }
+  return { intent: "ambiguous", hint: `name "${name}" has no exempt/protect signal` };
+}
+function looksLikeRoutePattern(s) {
+  return s.startsWith("/") && !s.startsWith("//");
+}
+function collectStringsFromArray(arrNode) {
+  const out = [];
+  for (const child of arrNode.children) {
+    if (child.type !== "string") continue;
+    const frag = childOfType(child, "string_fragment");
+    if (frag) out.push(frag.text);
+  }
+  return out;
+}
+function findArrayInValue(valueNode) {
+  if (!valueNode) return null;
+  if (valueNode.type === "array") return valueNode;
+  if (valueNode.type === "call_expression") {
+    const args = childOfType(valueNode, "arguments");
+    if (!args) return null;
+    for (const c of args.children) {
+      if (c.type === "array") return c;
+    }
+  }
+  return null;
+}
+function extractMatcherFromDeclarator(decl) {
+  const nameNode = childOfType(decl, "identifier");
+  if (!nameNode) return null;
+  let valueNode;
+  for (const c of decl.children) {
+    if (c.type === "identifier" || c.type === "=" || c.type === "type_annotation") continue;
+    valueNode = c;
+  }
+  const arr = findArrayInValue(valueNode);
+  if (!arr) return null;
+  const strings = collectStringsFromArray(arr);
+  const routes = strings.filter(looksLikeRoutePattern);
+  if (routes.length === 0) return null;
+  const { intent, hint } = inferIntentFromName(nameNode.text);
+  return { name: nameNode.text, patterns: routes, intent, hint };
+}
+function extractMatchersFromObject(objNode) {
+  const out = [];
+  for (const pair of childrenOfType(objNode, "pair")) {
+    const key = childOfType(pair, "property_identifier");
+    if (!key) continue;
+    const arr = pair.children.find((c) => c.type === "array");
+    if (!arr) continue;
+    const routes = collectStringsFromArray(arr).filter(looksLikeRoutePattern);
+    if (routes.length === 0) continue;
+    const { intent, hint } = inferIntentFromName(key.text);
+    out.push({ name: key.text, patterns: routes, intent, hint });
+  }
+  return out;
+}
+function detectFallthroughProtect(root) {
+  const text = root.text;
+  const signals = [
+    /\bauth\.protect\s*\(/,
+    /\bauth\(\)\.protect\s*\(/,
+    /\bredirect\s*\(\s*['"`]\/(sign-?in|log-?in|auth)/i,
+    /\bNextResponse\.redirect\s*\(/,
+    /\bthrow\s+new\s+\w*Unauthorized/i
+  ];
+  return signals.some((re) => re.test(text));
+}
+function extractMiddlewareAuthTS(absPath) {
+  if (!require("node:fs").existsSync(absPath)) return null;
+  const tree = parseSource(absPath);
+  if (!tree) return null;
+  const root = tree.rootNode;
+  const matchers = [];
+  for (const stmt of root.children) {
+    if (stmt.type !== "lexical_declaration" && stmt.type !== "variable_declaration") continue;
+    for (const decl of childrenOfType(stmt, "variable_declarator")) {
+      const m = extractMatcherFromDeclarator(decl);
+      if (m) matchers.push(m);
+      let valueNode;
+      for (const c of decl.children) {
+        if (c.type === "identifier" || c.type === "=" || c.type === "type_annotation") continue;
+        valueNode = c;
+      }
+      if (valueNode?.type === "object") {
+        for (const inner of extractMatchersFromObject(valueNode)) matchers.push(inner);
+      }
+    }
+  }
+  for (const stmt of root.children) {
+    if (stmt.type !== "export_statement") continue;
+    const decl = childOfType(stmt, "lexical_declaration") ?? childOfType(stmt, "variable_declaration");
+    if (!decl) continue;
+    for (const d of childrenOfType(decl, "variable_declarator")) {
+      let valueNode;
+      for (const c of d.children) {
+        if (c.type === "identifier" || c.type === "=" || c.type === "type_annotation") continue;
+        valueNode = c;
+      }
+      if (valueNode?.type === "object") {
+        for (const inner of extractMatchersFromObject(valueNode)) matchers.push(inner);
+      }
+      const m = extractMatcherFromDeclarator(d);
+      if (m && !matchers.some((x) => x.name === m.name && x.patterns.join() === m.patterns.join())) {
+        matchers.push(m);
+      }
+    }
+  }
+  return {
+    file: absPath,
+    matchers,
+    hasFallthroughProtect: detectFallthroughProtect(root)
+  };
+}
+function middlewarePatternToRegex(pattern) {
+  const negLookaheadMatch = /^(\/?)\(\(\?\!([^)]+)\)(\.\*|\.\+)\)$/.exec(pattern);
+  if (negLookaheadMatch) {
+    const [, lead, altsRaw, body] = negLookaheadMatch;
+    const escapedAlts = altsRaw.split("|").map((alt) => alt.trim().replace(/[.+*?^${}()|[\]\\]/g, "\\$&")).join("|");
+    try {
+      return new RegExp(`^${lead}(?!${escapedAlts})${body}$`);
+    } catch {
+      return null;
+    }
+  }
+  if (/\(\?\!/.test(pattern)) return null;
+  if (pattern.startsWith("(")) return null;
+  let src = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "(" && pattern.slice(i, i + 4) === "(.*)") {
+      src += ".*";
+      i += 4;
+      continue;
+    }
+    if (ch === ":") {
+      i++;
+      while (i < pattern.length && /[a-zA-Z0-9_]/.test(pattern[i])) i++;
+      src += "[^/]+";
+      continue;
+    }
+    if (ch === "*") {
+      i++;
+      while (i < pattern.length && /[a-zA-Z0-9_]/.test(pattern[i])) i++;
+      if (pattern[i] === "?") {
+        i++;
+        src += ".*";
+        continue;
+      }
+      src += ".+";
+      continue;
+    }
+    if (/[.\\+?^${}()|[\]]/.test(ch)) {
+      src += "\\" + ch;
+      i++;
+      continue;
+    }
+    src += ch;
+    i++;
+  }
+  src += "$";
+  try {
+    return new RegExp(src);
+  } catch {
+    return null;
+  }
+}
+function classifyRouteAgainstMiddleware(routePath, info) {
+  for (const m of info.matchers) {
+    if (m.intent === "ambiguous") continue;
+    for (const pat of m.patterns) {
+      const re = middlewarePatternToRegex(pat);
+      if (!re) continue;
+      if (re.test(routePath)) return { intent: m.intent, matcher: m.name, pattern: pat };
+    }
+  }
+  return null;
+}
+function trunc(s, max = 120) {
+  return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function dedup(arr) {
+  return Array.from(new Set(arr));
+}
+function firstStringArg(callExpr) {
+  const args = callExpr.childForFieldName("arguments");
+  if (!args) return null;
+  for (const c of args.namedChildren) {
+    if (c.type === "string") {
+      const frag = c.namedChildren.find((cc) => cc.type === "string_fragment");
+      return frag ? frag.text : c.text.replace(/^['"`]|['"`]$/g, "");
+    }
+    if (c.type === "template_string") {
+      return c.text.replace(/^`|`$/g, "");
+    }
+  }
+  return null;
+}
+function isFunctionLike(node) {
+  return node.type === "arrow_function" || node.type === "function_expression" || node.type === "function_declaration" || node.type === "method_definition" || node.type === "generator_function" || node.type === "generator_function_declaration";
+}
+function stringLiteralValue(n) {
+  if (n.type !== "string") return null;
+  const frag = n.namedChildren.find((c) => c.type === "string_fragment");
+  if (frag) return frag.text;
+  return n.text.replace(/^['"`]|['"`]$/g, "");
+}
+function nthStringArg(callExpr, idx) {
+  const args = callExpr.childForFieldName("arguments");
+  if (!args) return null;
+  const child = args.namedChildren[idx];
+  return child ? stringLiteralValue(child) : null;
+}
+function objectArgIdValues(callExpr) {
+  const args = callExpr.childForFieldName("arguments");
+  if (!args) return [];
+  const out = [];
+  for (const arg of args.namedChildren) {
+    if (arg.type !== "object") continue;
+    for (const pair of arg.namedChildren) {
+      if (pair.type !== "pair") continue;
+      const key = pair.childForFieldName("key");
+      const val = pair.childForFieldName("value");
+      if (!key || !val) continue;
+      const keyText = key.type === "property_identifier" ? key.text : stringLiteralValue(key) ?? key.text;
+      if (keyText !== "id") continue;
+      const strVal = stringLiteralValue(val);
+      if (strVal) out.push(strVal);
+    }
+  }
+  return out;
+}
+function extractEffects(node, moduleOnly = false) {
+  const calls = [];
+  const dom_writes = [];
+  const subscribes = [];
+  const timers = [];
+  const persists = [];
+  const fetches = [];
+  const globals = [];
+  const dom_ids = [];
+  const window_events = [];
+  const storage_keys = [];
+  const fetch_urls = [];
+  function visit(n, depth) {
+    if (moduleOnly && depth > 0 && isFunctionLike(n)) return;
+    if (n.type === "call_expression") {
+      const fn = n.childForFieldName("function");
+      if (fn) {
+        const fnText = fn.text;
+        calls.push(fnText);
+        for (const id of objectArgIdValues(n)) dom_ids.push(id);
+        if (fn.type === "identifier") {
+          if (TIMER_FNS.has(fnText)) timers.push(fnText);
+          if (fnText === "fetch") {
+            const url = firstStringArg(n);
+            fetches.push(url ? `fetch("${url}")` : "fetch(...)");
+            if (url) fetch_urls.push(url);
+          }
+        } else if (fn.type === "member_expression") {
+          const obj = fn.childForFieldName("object");
+          const prop = fn.childForFieldName("property");
+          const objText = obj?.text ?? "";
+          const propText = prop?.text ?? "";
+          if (STORAGE_OBJECTS.has(objText)) {
+            const key = firstStringArg(n);
+            persists.push(key ? `${objText}.${propText}("${key}")` : `${objText}.${propText}(\u2026)`);
+            if (key) storage_keys.push(key);
+          } else if (propText === "addEventListener") {
+            const event = firstStringArg(n);
+            subscribes.push(event ? `${objText}.addEventListener("${event}")` : `${objText}.addEventListener(\u2026)`);
+            if (event && (objText === "window" || objText === "document")) {
+              window_events.push(`${objText}:${event}`);
+            }
+          } else if (propText === "removeEventListener") {
+            const event = firstStringArg(n);
+            subscribes.push(event ? `${objText}.removeEventListener("${event}")` : `${objText}.removeEventListener(\u2026)`);
+          } else if (propText === "subscribe" || propText === "on") {
+            subscribes.push(`${objText}.${propText}(\u2026)`);
+          } else if (DOM_METHOD_NAMES.has(propText)) {
+            dom_writes.push(`${objText}.${propText}(\u2026)`);
+            if (propText === "setAttribute" && nthStringArg(n, 0) === "id") {
+              const idVal = nthStringArg(n, 1);
+              if (idVal) dom_ids.push(idVal);
+            }
+          } else if (objText.endsWith(".classList") && CLASSLIST_METHODS.has(propText)) {
+            dom_writes.push(`${objText}.${propText}(\u2026)`);
+          } else if (objText === "history" && HISTORY_METHODS.has(propText)) {
+            globals.push(`history.${propText}(\u2026)`);
+          } else if (objText === "location" && LOCATION_METHODS.has(propText)) {
+            globals.push(`location.${propText}(\u2026)`);
+          } else if (objText === "window" && propText === "matchMedia") {
+            globals.push("window.matchMedia(\u2026)");
+          }
+        }
+      }
+    } else if (n.type === "assignment_expression") {
+      const lhs = n.children.find((c) => c.type !== "=");
+      const rhs = n.childForFieldName("right");
+      if (lhs?.type === "member_expression") {
+        const prop = lhs.childForFieldName("property");
+        const propText = prop?.text ?? "";
+        const lhsText = lhs.text;
+        if (lhsText.startsWith("document.cookie")) {
+          persists.push("document.cookie =");
+        } else if (lhsText.startsWith("document.title") || lhsText.startsWith("location.")) {
+          globals.push(`${lhsText} =`);
+        } else if (ASSIGN_DOM_PROPS.has(propText) || lhsText.includes(".style.") || lhsText.includes(".dataset.")) {
+          dom_writes.push(`${lhsText} =`);
+          if (propText === "id" && rhs) {
+            const idVal = stringLiteralValue(rhs);
+            if (idVal) dom_ids.push(idVal);
+          }
+        }
+      }
+    }
+    for (const child of n.children) visit(child, depth + 1);
+  }
+  visit(node, 0);
+  const out = {};
+  if (calls.length) out.calls = dedup(calls);
+  if (dom_writes.length) out.dom_writes = dedup(dom_writes);
+  if (subscribes.length) out.subscribes = dedup(subscribes);
+  if (timers.length) out.timers = dedup(timers);
+  if (persists.length) out.persists = dedup(persists);
+  if (fetches.length) out.fetches = dedup(fetches);
+  if (globals.length) out.globals = dedup(globals);
+  if (dom_ids.length) out.dom_ids = dedup(dom_ids);
+  if (window_events.length) out.window_events = dedup(window_events);
+  if (storage_keys.length) out.storage_keys = dedup(storage_keys);
+  if (fetch_urls.length) out.fetch_urls = dedup(fetch_urls);
+  return out;
+}
+function extractDeep(absPath) {
+  const tree = parseSource(absPath);
+  if (!tree) {
+    return { elements: [], stateVars: [], conditions: [], variables: [], responses: [], params: [] };
+  }
+  const root = tree.rootNode;
+  const elements = [];
+  const elQuery = getQuery("deep/jsx-semantic");
+  const elMatches = elQuery.matches(root);
+  const elementMap = /* @__PURE__ */ new Map();
+  for (const m of elMatches) {
+    const tag = m.captures.find((c) => c.name === "el.tag")?.node;
+    if (!tag || !/^[A-Z]/.test(tag.text)) continue;
+    const elNode = m.captures.find((c) => c.name === "el.self" || c.name === "el.open")?.node;
+    const key = elNode ? `${elNode.startPosition.row}:${elNode.startPosition.column}` : `${tag.startPosition.row}:${tag.startPosition.column}`;
+    if (!elementMap.has(key)) {
+      elementMap.set(key, { tag: tag.text, props: {}, nodeKey: key });
+    }
+    const entry = elementMap.get(key);
+    const propName = m.captures.find((c) => c.name === "el.prop.name")?.node.text;
+    const propVal = m.captures.find((c) => c.name === "el.prop.value.str")?.node.text;
+    const propExpr = m.captures.find((c) => c.name === "el.prop.value.expr")?.node.text;
+    if (propName) {
+      entry.props[propName] = propVal ?? (propExpr ? trunc(propExpr, 60) : "true");
+    }
+  }
+  for (const m of elMatches) {
+    const textTag = m.captures.find((c) => c.name === "el.text.tag")?.node;
+    const textContent = m.captures.find((c) => c.name === "el.text.content")?.node;
+    if (textTag && textContent && /^[A-Z]/.test(textTag.text)) {
+      const key = `${textTag.startPosition.row}:${textTag.startPosition.column}`;
+      if (!elementMap.has(key)) {
+        elementMap.set(key, { tag: textTag.text, props: {}, nodeKey: key });
+      }
+      const entry = elementMap.get(key);
+      const text = textContent.text.trim();
+      if (text) entry.props["_text"] = text;
+    }
+  }
+  for (const entry of elementMap.values()) {
+    const el = { tag: entry.tag, props: entry.props };
+    const hasExpr = Object.values(entry.props).some((v) => v.includes("{") || v.includes("("));
+    if (hasExpr) el.dynamic = true;
+    if (entry.props["_text"]) {
+      el.text = entry.props["_text"];
+      delete el.props["_text"];
+    }
+    elements.push(el);
+  }
+  const stateVars = [];
+  const hookQuery = getQuery("deep/state-hooks");
+  const hookMatches = hookQuery.matches(root);
+  for (const m of hookMatches) {
+    const caps = captureMap(m);
+    if (caps["hook.var"] && caps["hook.setter"] && caps["hook.fn"]) {
+      stateVars.push({
+        name: caps["hook.var"],
+        setter: caps["hook.setter"],
+        hook: caps["hook.fn"],
+        init: trunc(caps["hook.init"] ?? "", 80)
+      });
+    }
+    if (caps["reducer.var"] && caps["reducer.dispatch"]) {
+      stateVars.push({
+        name: caps["reducer.var"],
+        setter: caps["reducer.dispatch"],
+        hook: "useReducer",
+        init: trunc(caps["reducer.init"] ?? "", 80)
+      });
+    }
+  }
+  const conditions = [];
+  const condQuery = getQuery("deep/conditions");
+  const condMatches = condQuery.matches(root);
+  for (const m of condMatches) {
+    const caps = captureMap(m);
+    if (caps["cond.test"]) {
+      conditions.push({
+        kind: "if",
+        test: trunc(caps["cond.test"], 100),
+        consequence: caps["cond.consequence"] ? trunc(caps["cond.consequence"], 80) : void 0
+      });
+    }
+    if (caps["ternary.test"]) {
+      conditions.push({
+        kind: "ternary",
+        test: trunc(caps["ternary.test"], 100)
+      });
+    }
+  }
+  const variables = [];
+  const varQuery = getQuery("deep/variables");
+  const varMatches = varQuery.matches(root);
+  for (const m of varMatches) {
+    const caps = captureMap(m);
+    const declNode = m.captures.find((c) => c.name === "var.decl" || c.name === "var.destructured" || c.name === "var.array")?.node;
+    const kind = declNode?.children.find((n) => n.type === "const" || n.type === "let" || n.type === "var")?.type ?? "const";
+    const initNode = m.captures.find((c) => c.name === "var.init")?.node;
+    if (caps["var.name"] && caps["var.init"]) {
+      const variable = {
+        name: caps["var.name"],
+        kind,
+        init: trunc(caps["var.init"], 100)
+      };
+      if (initNode && isFunctionLike(initNode)) {
+        const eff = extractEffects(initNode);
+        if (Object.keys(eff).length > 0) variable.effects = eff;
+      }
+      variables.push(variable);
+    }
+    if (caps["var.destructured.obj"]) {
+      variables.push({
+        name: trunc(caps["var.destructured.obj"], 60),
+        kind,
+        init: trunc(caps["var.destructured.init"], 100)
+      });
+    }
+    if (caps["var.array.pattern"]) {
+      variables.push({
+        name: trunc(caps["var.array.pattern"], 60),
+        kind,
+        init: trunc(caps["var.array.init"], 100)
+      });
+    }
+  }
+  const responses = [];
+  const respQuery = getQuery("deep/responses");
+  const respMatches = respQuery.matches(root);
+  const explicitBodies = /* @__PURE__ */ new Set();
+  for (const m of respMatches) {
+    const caps = captureMap(m);
+    if (caps["resp.status"] && caps["resp.body"]) {
+      explicitBodies.add(trunc(caps["resp.body"], 80));
+      responses.push({
+        status: caps["resp.status"],
+        body: trunc(caps["resp.body"], 80)
+      });
+    }
+  }
+  for (const m of respMatches) {
+    const caps = captureMap(m);
+    if (caps["resp.body.default"] && !caps["resp.status"]) {
+      const bodyText = trunc(caps["resp.body.default"], 80);
+      if (!explicitBodies.has(bodyText)) {
+        responses.push({ status: "200", body: bodyText });
+      }
+    }
+  }
+  const params = [];
+  const paramQuery = getQuery("deep/request-params");
+  const paramMatches = paramQuery.matches(root);
+  for (const m of paramMatches) {
+    const caps = captureMap(m);
+    if (caps["param.name"]) {
+      params.push({ name: caps["param.name"], source: "body-field" });
+    }
+    if (caps["param.body"]) {
+      params.push({ name: caps["param.body"], source: "body" });
+    }
+  }
+  const fileEffects = extractEffects(
+    root,
+    /* moduleOnly */
+    false
+  );
+  const hasEffects = Object.keys(fileEffects).length > 0;
+  return {
+    elements,
+    stateVars,
+    conditions,
+    variables,
+    responses,
+    params,
+    ...hasEffects ? { effects: fileEffects } : {}
+  };
+}
+var import_node_fs5, import_node_path5, 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;
+var init_ts_extractor = __esm({
+  "src/server/graph/core/ts-extractor.ts"() {
+    "use strict";
+    import_node_fs5 = require("node:fs");
+    import_node_path5 = require("node:path");
+    init_parse_failure_cache();
+    initialized = false;
+    queriesDir = (() => {
+      const srcPath = (0, import_node_path5.join)((0, import_node_path5.dirname)(__filename), "..", "queries");
+      if (require("fs").existsSync(srcPath)) return srcPath;
+      return (0, import_node_path5.join)((0, import_node_path5.dirname)(__filename), "graph", "queries");
+    })();
+    queryCache = /* @__PURE__ */ new Map();
+    MAX_PARSEABLE_BYTES = 2 * 1024 * 1024;
+    MAX_CONSECUTIVE_PARSE_FAILURES = 10;
+    consecutiveParseFailures = 0;
+    ParseCascadeError = class extends Error {
+      constructor(lastPath, failureCount) {
+        super(
+          `tree-sitter parse cascade: ${failureCount} consecutive WASM failures (last file: ${lastPath}). The shared Parser's WASM heap is likely corrupted; aborting regen so the graph isn't silently degraded. Restart the chart server to reinitialize, then re-run generate_graph.`
+        );
+        this.lastPath = lastPath;
+        this.failureCount = failureCount;
+        this.name = "ParseCascadeError";
+      }
+    };
+    PRISMA_MUTATION_METHODS_BUILTIN = [
+      "create",
+      "createMany",
+      "createManyAndReturn",
+      "update",
+      "updateMany",
+      "updateManyAndReturn",
+      "upsert",
+      "delete",
+      "deleteMany"
+    ];
+    SUPABASE_MUTATION_METHODS_BUILTIN = /* @__PURE__ */ new Set([
+      "insert",
+      "update",
+      "delete",
+      "upsert"
+    ]);
+    DB_IDENTIFIERS_FALLBACK = ["db", "prisma"];
+    extraDbIdentifiers = [];
+    extraMutationMethods = [];
+    INLINE_AUTH_IMPORTS = [
+      { module: /^@clerk\/nextjs(\/server)?$/, helpers: ["auth", "currentUser"] },
+      { module: /^next-auth(\/.+)?$/, helpers: ["auth", "getServerSession"] },
+      { module: /^@auth\//, helpers: ["auth"] },
+      { module: /^@supabase\/auth-helpers/, helpers: ["createServerClient"] }
+    ];
+    EXEMPT_NAME_PATTERNS = [
+      /^is_?public/i,
+      /^public_?routes?/i,
+      /^public_?paths?/i,
+      /^whitelist/i,
+      /^allowlist/i,
+      /^unauthenticated/i,
+      /^anonymous/i,
+      /^guest/i,
+      /^skip_?auth/i,
+      /^bypass/i
+    ];
+    PROTECT_NAME_PATTERNS = [
+      /^is_?protected/i,
+      /^protected_?routes?/i,
+      /^protected_?paths?/i,
+      /^require_?auth/i,
+      /^auth_?required/i,
+      /^private_?routes?/i,
+      /^is_?admin/i,
+      /^admin_?routes?/i,
+      /^secured/i
+    ];
+    TRUST_AS_PROTECT_KEYS = /* @__PURE__ */ new Set(["matcher", "matchers"]);
+    TIMER_FNS = /* @__PURE__ */ new Set([
+      "setInterval",
+      "setTimeout",
+      "clearInterval",
+      "clearTimeout",
+      "requestAnimationFrame",
+      "cancelAnimationFrame",
+      "queueMicrotask"
+    ]);
+    DOM_METHOD_NAMES = /* @__PURE__ */ new Set([
+      "setAttribute",
+      "removeAttribute",
+      "appendChild",
+      "removeChild",
+      "replaceChildren",
+      "replaceWith",
+      "insertBefore",
+      "append",
+      "prepend",
+      "remove",
+      "before",
+      "after",
+      "insertAdjacentHTML",
+      "insertAdjacentElement"
+    ]);
+    CLASSLIST_METHODS = /* @__PURE__ */ new Set(["add", "remove", "toggle", "replace"]);
+    STORAGE_OBJECTS = /* @__PURE__ */ new Set(["localStorage", "sessionStorage"]);
+    HISTORY_METHODS = /* @__PURE__ */ new Set(["pushState", "replaceState", "back", "forward", "go"]);
+    LOCATION_METHODS = /* @__PURE__ */ new Set(["assign", "replace", "reload"]);
+    ASSIGN_DOM_PROPS = /* @__PURE__ */ new Set([
+      "textContent",
+      "innerHTML",
+      "innerText",
+      "value",
+      "src",
+      "href",
+      "className",
+      "id",
+      "checked",
+      "selected",
+      "disabled"
+    ]);
+  }
+});
+
+// src/server/parse-worker-entry.ts
+var parse_worker_entry_exports = {};
+module.exports = __toCommonJS(parse_worker_entry_exports);
+var import_node_worker_threads = require("node:worker_threads");
+
+// src/server/graph/core/config.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+init_launch_kit_paths();
+function loadConfig(rootDir) {
+  const configPath = (0, import_node_path.join)(rootDir, LAUNCHCHART_CONFIG_FILE);
+  if (!(0, import_node_fs.existsSync)(configPath)) return {};
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+// src/server/graph/core/graph-builder.ts
+var import_node_fs13 = require("node:fs");
+var import_node_path14 = require("node:path");
+init_launch_kit_paths();
+
+// src/server/graph/core/parser-registry.ts
+var import_node_path13 = require("node:path");
+
+// src/server/graph/parsers/ts/typescript-project.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
+
+// src/server/graph/core/resolve-paths.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+
+// src/server/graph/core/walk.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage"
+]);
+function walk(dir, exts) {
+  const results = [];
+  if (!(0, import_node_fs2.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path2.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk(full, exts));
+    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function walkWithIgnore(dir, exts, opts = {}) {
+  const results = [];
+  if (!(0, import_node_fs2.existsSync)(dir)) return results;
+  const skip = opts.extraIgnore ? /* @__PURE__ */ new Set([...DEFAULT_IGNORE_DIRS, ...opts.extraIgnore]) : DEFAULT_IGNORE_DIRS;
+  for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".")) continue;
+      if (skip.has(entry.name)) continue;
+      results.push(...walkWithIgnore((0, import_node_path2.join)(dir, entry.name), exts, opts));
+    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
+      results.push((0, import_node_path2.join)(dir, entry.name));
+    }
+  }
+  return results;
+}
+
+// src/server/graph/core/resolve-paths.ts
+function hasSqlFiles(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return false;
+  try {
+    return (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isFile() && e.name.endsWith(".sql")
+    );
+  } catch {
+    return false;
+  }
+}
+function hasNestedMigrationSql(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return false;
+  try {
+    return (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true }).some(
+      (e) => e.isDirectory() && (0, import_node_fs3.existsSync)((0, import_node_path3.join)(dir, e.name, "migration.sql"))
+    );
+  } catch {
+    return false;
+  }
+}
+function resolveDbFromDir(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return { kind: "none", schemaPath: null, migrationsDir: null };
+  const schemaPath = (0, import_node_path3.join)(dir, "schema.prisma");
+  if ((0, import_node_fs3.existsSync)(schemaPath)) {
+    const migrationsDir2 = (0, import_node_path3.join)(dir, "migrations");
+    return {
+      kind: "prisma",
+      schemaPath,
+      migrationsDir: (0, import_node_fs3.existsSync)(migrationsDir2) ? migrationsDir2 : null
+    };
+  }
+  const migrationsDir = (0, import_node_path3.join)(dir, "migrations");
+  if (hasSqlFiles(migrationsDir) || hasNestedMigrationSql(migrationsDir)) {
+    return { kind: "sql-migrations", migrationsDir, schemaPath: null };
+  }
+  if (hasSqlFiles(dir) || hasNestedMigrationSql(dir)) {
+    return { kind: "sql-migrations", migrationsDir: dir, schemaPath: null };
+  }
+  return { kind: "none", schemaPath: null, migrationsDir: null };
+}
+function detectDbConfig(rootDir, config) {
+  if (config.paths?.dbDir) {
+    return resolveDbFromDir((0, import_node_path3.join)(rootDir, config.paths.dbDir));
+  }
+  const candidates = ["prisma", "supabase", "drizzle", (0, import_node_path3.join)("db", "migrations"), "migrations"];
+  for (const c of candidates) {
+    const dir = (0, import_node_path3.join)(rootDir, c);
+    const resolved = resolveDbFromDir(dir);
+    if (resolved.kind !== "none") return resolved;
+  }
+  return { kind: "none", schemaPath: null, migrationsDir: null };
+}
+function detectDbDir(rootDir, config, dbConfig) {
+  if (config.paths?.dbDir) return (0, import_node_path3.join)(rootDir, config.paths.dbDir);
+  if (dbConfig.kind === "prisma") return (0, import_node_path3.dirname)(dbConfig.schemaPath);
+  if (dbConfig.kind === "sql-migrations") return dbConfig.migrationsDir;
+  return null;
+}
+var NON_SOURCE_DIRS = /* @__PURE__ */ new Set([
+  ...DEFAULT_IGNORE_DIRS,
+  // DB conventions (handled by db parsers)
+  "prisma",
+  "supabase",
+  "drizzle",
+  "migrations",
+  // Web assets
+  "public",
+  "static",
+  "assets",
+  // Docs
+  "docs",
+  "documentation",
+  // Test dirs (project tests aren't part of the structural graph)
+  "tests",
+  "__tests__",
+  "e2e",
+  "playwright",
+  "cypress",
+  // Monorepo workspace roots — separate graph projects per .launchchart.json
+  "packages",
+  "apps",
+  "services",
+  "libs"
+]);
+function dirHasTSFiles(dir) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return false;
+  try {
+    const stack = [dir];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      const entries = (0, import_node_fs3.readdirSync)(cur, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx"))) return true;
+        if (e.isDirectory() && !e.name.startsWith(".") && !DEFAULT_IGNORE_DIRS.has(e.name)) {
+          stack.push((0, import_node_path3.join)(cur, e.name));
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function collectCodeBearingChildren(dir, extraSkip) {
+  if (!(0, import_node_fs3.existsSync)(dir)) return [];
+  const out = [];
+  try {
+    for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      if (NON_SOURCE_DIRS.has(entry.name)) continue;
+      if (extraSkip?.has(entry.name)) continue;
+      const full = (0, import_node_path3.join)(dir, entry.name);
+      if (dirHasTSFiles(full)) out.push(full);
+    }
+  } catch {
+  }
+  return out;
+}
+function detectSrcRoots(rootDir, srcDir, appDir, config) {
+  if (config.paths?.srcRoots && config.paths.srcRoots.length > 0) {
+    const roots2 = /* @__PURE__ */ new Set();
+    roots2.add(appDir);
+    for (const r of config.paths.srcRoots) {
+      const abs = (0, import_node_path3.isAbsolute)(r) ? r : (0, import_node_path3.resolve)(rootDir, r);
+      roots2.add(abs);
+    }
+    return [...roots2];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  roots.add(appDir);
+  for (const c of collectCodeBearingChildren(srcDir)) roots.add(c);
+  if (srcDir !== rootDir) {
+    const skipSrcWrapper = /* @__PURE__ */ new Set([(0, import_node_path3.basename)(srcDir)]);
+    for (const c of collectCodeBearingChildren(rootDir, skipSrcWrapper)) roots.add(c);
+  }
+  return [...roots];
+}
+var CONVENTION_NAMES = ["middleware.ts", "middleware.tsx", "instrumentation.ts", "instrumentation.tsx"];
+function detectConventionFiles(rootDir, srcDir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dirs = srcDir === rootDir ? [rootDir] : [srcDir, rootDir];
+  for (const dir of dirs) {
+    for (const name of CONVENTION_NAMES) {
+      const full = (0, import_node_path3.join)(dir, name);
+      if (!seen.has(full) && (0, import_node_fs3.existsSync)(full)) {
+        try {
+          if ((0, import_node_fs3.statSync)(full).isFile()) {
+            seen.add(full);
+            out.push(full);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return out;
+}
+function resolveProjectPaths(rootDir, config) {
+  let srcDir;
+  let appDir;
+  if (config.paths?.appDir) {
+    appDir = (0, import_node_path3.join)(rootDir, config.paths.appDir);
+    srcDir = config.paths.srcDir ? (0, import_node_path3.join)(rootDir, config.paths.srcDir) : (0, import_node_path3.dirname)(appDir);
+  } else {
+    const srcApp = (0, import_node_path3.join)(rootDir, "src", "app");
+    const rootApp = (0, import_node_path3.join)(rootDir, "app");
+    if ((0, import_node_fs3.existsSync)(srcApp)) {
+      srcDir = (0, import_node_path3.join)(rootDir, "src");
+      appDir = srcApp;
+    } else if ((0, import_node_fs3.existsSync)(rootApp)) {
+      srcDir = rootDir;
+      appDir = rootApp;
+    } else {
+      return null;
+    }
+  }
+  const apiDir = (0, import_node_path3.join)(appDir, "api");
+  const dbConfig = detectDbConfig(rootDir, config);
+  const dbDir = detectDbDir(rootDir, config, dbConfig);
+  const srcRoots = detectSrcRoots(rootDir, srcDir, appDir, config);
+  const conventionFiles = detectConventionFiles(rootDir, srcDir);
+  return { srcDir, appDir, apiDir, dbDir, srcRoots, conventionFiles, dbConfig };
+}
+
+// src/server/graph/parsers/ts/typescript-project.ts
+init_ts_extractor();
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+var CLASSIFICATION_TO_LAYER = {
+  endpoint: "api",
+  "server-action": "api",
+  page: "ui",
+  layout: "ui",
+  component: "ui",
+  ui: "ui",
+  hook: "ui",
+  context: "ui",
+  config: "ui",
+  lib: "ui",
+  "mcp-tool": "ui",
+  middleware: "ui",
+  external: "ui"
+};
+function toNodeId(srcDir, rootDir, absPath) {
+  const relFromSrc = (0, import_node_path6.relative)(srcDir, absPath).replace(/\\/g, "/");
+  if (relFromSrc.startsWith("..")) {
+    return (0, import_node_path6.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_path6.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path6.join)(base, "index.ts"), (0, import_node_path6.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs6.existsSync)(c) && (0, import_node_fs6.statSync)(c).isFile()) return c;
+  }
+  return null;
+}
+function resolveRelativeImport(fromFile, specifier) {
+  const base = (0, import_node_path6.join)((0, import_node_path6.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path6.join)(base, "index.ts"), (0, import_node_path6.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs6.existsSync)(c) && (0, import_node_fs6.statSync)(c).isFile()) return c;
+  }
+  return null;
+}
+function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
+  const cached = memo.get(barrelAbsPath);
+  if (cached) return cached;
+  if (visiting.has(barrelAbsPath)) return /* @__PURE__ */ new Map();
+  visiting.add(barrelAbsPath);
+  const parsed = parsedByPath.get(barrelAbsPath);
+  const map = /* @__PURE__ */ new Map();
+  if (!parsed) {
+    visiting.delete(barrelAbsPath);
+    memo.set(barrelAbsPath, map);
+    return map;
+  }
+  for (const re of parsed.reExports) {
+    if (!re.from.startsWith(".")) continue;
+    const resolved = resolveRelativeImport(barrelAbsPath, re.from);
+    if (!resolved) continue;
+    if (re.isWildcard) {
+      const targetBn = (0, import_node_path6.basename)(resolved);
+      const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
+      if (targetIsBarrel) {
+        const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
+        for (const [name, target] of nested) {
+          if (!map.has(name)) map.set(name, target);
+        }
+      } else {
+        const targetParsed = parsedByPath.get(resolved);
+        if (targetParsed) {
+          for (const exp of targetParsed.exports) {
+            if (!map.has(exp)) map.set(exp, resolved);
+          }
+        }
+      }
+    } else {
+      if (!map.has(re.name)) map.set(re.name, resolved);
+    }
+  }
+  visiting.delete(barrelAbsPath);
+  memo.set(barrelAbsPath, map);
+  return map;
+}
+function buildAllBarrelMaps(srcDir, parsedByPath) {
+  const barrels = /* @__PURE__ */ new Map();
+  const memo = /* @__PURE__ */ new Map();
+  for (const [absPath, parsed] of parsedByPath) {
+    const bn = (0, import_node_path6.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_path6.relative)(srcDir, (0, import_node_path6.dirname)(absPath)).replace(/\\/g, "/");
+      barrels.set(barrelId, map);
+    }
+  }
+  return barrels;
+}
+function classifyType(absPath, id) {
+  const contentType = classifyFile(absPath);
+  if (contentType === "lib" && id.startsWith("server/mcp/")) return "mcp-tool";
+  if (/^app\/(.+\/)?page\.tsx$/.test(id)) return "page";
+  if (/^app\/(.+\/)?layout\.tsx$/.test(id)) return "layout";
+  return contentType;
+}
+function extractRoute(id) {
+  if (!id.endsWith("/page.tsx")) return null;
+  let route = id.replace(/^app\//, "/").replace(/\/page\.tsx$/, "");
+  route = route.replace(/\/\([^)]+\)/g, "");
+  route = route.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "*$1?");
+  route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  route = route.replace(/\/+/g, "/");
+  if (!route.startsWith("/")) route = "/" + route;
+  return route || "/";
+}
+function nameFromFilename(absPath) {
+  return (0, import_node_path6.basename)(absPath, (0, import_node_path6.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+}
+function filePathToAppRoute(appDir, absPath) {
+  let route = ("/" + (0, import_node_path6.relative)(appDir, absPath).replace(/\\/g, "/")).replace(/\/route\.tsx?$/, "");
+  route = route.replace(/\/\([^)]+\)/g, "");
+  route = route.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "*$1?");
+  route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*$1");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  route = route.replace(/\/+/g, "/");
+  return route === "" ? "/" : route;
+}
+function camelToPascal(s) {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function resolveTemplateLiteralRoute(template, routeToNodeId) {
+  const parameterized = template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    const cleaned = expr.trim();
+    if (cleaned.includes(".")) {
+      const parts = cleaned.split(".");
+      const last = parts[parts.length - 1];
+      const secondLast = parts.length > 1 ? parts[parts.length - 2] : "";
+      if (last === "slug" && secondLast === "project") return ":projectSlug";
+      if (last === "slug") return ":projectSlug";
+      if (last === "id" && /cred/i.test(secondLast)) return ":credentialId";
+      if (last === "id" && /run/i.test(secondLast)) return ":runId";
+      if (last === "sha") return ":commitSha";
+      if (last === "id") return ":id";
+      return `:${last}`;
+    }
+    if (/orgSlug/i.test(cleaned)) return ":orgSlug";
+    if (/projectSlug/i.test(cleaned)) return ":projectSlug";
+    if (/runId/i.test(cleaned)) return ":runId";
+    if (/credentialId/i.test(cleaned)) return ":credentialId";
+    if (/commitSha/i.test(cleaned)) return ":commitSha";
+    if (/token/i.test(cleaned)) return ":token";
+    return `:${cleaned}`;
+  });
+  const normalized = parameterized.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+  if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
+  let bestScore = -1;
+  let bestId = null;
+  for (const [route, nodeId] of routeToNodeId) {
+    const score = routeMatchScore(normalized, route);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = nodeId;
+    }
+  }
+  return bestScore > 0 ? bestId : null;
+}
+function routeMatchScore(candidate, known) {
+  const segsA = candidate.split("/");
+  const segsB = known.split("/");
+  let score = 0;
+  let i = 0, j = 0;
+  while (i < segsA.length && j < segsB.length) {
+    const a = segsA[i], b = segsB[j];
+    if (b.startsWith("*") && b.endsWith("?")) {
+      score += 1;
+      return score;
+    }
+    if (b.startsWith("*")) {
+      const remaining = segsA.length - i;
+      if (remaining < 1) return -1;
+      score += 1 + remaining;
+      return score;
+    }
+    if (a === b) {
+      score += 3;
+      i++;
+      j++;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      i++;
+      j++;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      i++;
+      j++;
+      continue;
+    }
+    return -1;
+  }
+  if (i === segsA.length) {
+    while (j < segsB.length) {
+      const b = segsB[j];
+      if (b.startsWith("*") && b.endsWith("?")) {
+        score += 1;
+        j++;
+        continue;
+      }
+      return -1;
+    }
+    return score;
+  }
+  return -1;
+}
+function templateToRoute(template) {
+  return template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    const cleaned = expr.trim();
+    if (cleaned.includes(".")) {
+      const parts = cleaned.split(".");
+      const last = parts[parts.length - 1];
+      const secondLast = parts.length > 1 ? parts[parts.length - 2] : "";
+      if (last === "slug" && /project/i.test(secondLast)) return ":projectSlug";
+      if (last === "slug") return ":slug";
+      if (last === "sha") return ":commitSha";
+      return `:${last}`;
+    }
+    return `:${cleaned}`;
+  });
+}
+function matchRouteToPage(route, routeToNodeId) {
+  const normalized = route.replace(/\/$/, "") || "/";
+  if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
+  return null;
+}
+function extractEdges(srcDir, rootDir, absPath, sourceId, parsed, nodeIdSet, barrelMaps, routeToNodeId) {
+  const edges = [];
+  const flagged = [];
+  const seen = /* @__PURE__ */ new Set();
+  function addEdge(target, type, label) {
+    const key = `${sourceId}\u2192${target}\u2192${type}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const edge = { source: sourceId, target, type };
+    if (label) edge.label = label;
+    edges.push(edge);
+  }
+  function edgeTypeFor(isTypeOnlyImport, importedNames) {
+    if (isTypeOnlyImport) return "imports_type";
+    const anyRendered = importedNames.some((n) => parsed.jsxElements.has(n));
+    if (anyRendered) return "renders";
+    return "imports";
+  }
+  for (const imp of parsed.imports) {
+    const { names, specifier, isTypeOnly, typeNames } = imp;
+    if (specifier.startsWith("@/")) {
+      const relToSrc = specifier.slice(2);
+      const barrelMap = barrelMaps.get(relToSrc);
+      if (barrelMap && names.length > 0) {
+        const byTarget = /* @__PURE__ */ new Map();
+        for (const name of names) {
+          const targetAbs = barrelMap.get(name);
+          if (targetAbs) {
+            const targetId = toNodeId(srcDir, rootDir, targetAbs);
+            if (nodeIdSet.has(targetId)) {
+              if (!byTarget.has(targetId)) byTarget.set(targetId, []);
+              byTarget.get(targetId).push(name);
+            }
+          }
+        }
+        for (const [targetId, targetNames] of byTarget) {
+          const allType = isTypeOnly || targetNames.every((n) => typeNames.has(n));
+          addEdge(targetId, edgeTypeFor(allType, targetNames));
+        }
+      } else {
+        const resolved = resolveImport(srcDir, specifier);
+        if (resolved) {
+          const targetId = toNodeId(srcDir, rootDir, resolved);
+          if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
+            const allType = isTypeOnly || names.length > 0 && names.every((n) => typeNames.has(n));
+            addEdge(targetId, edgeTypeFor(allType, names));
+          }
+        }
+      }
+    } else if (specifier.startsWith(".")) {
+      const resolved = resolveRelativeImport(absPath, specifier);
+      if (resolved) {
+        const targetId = toNodeId(srcDir, rootDir, resolved);
+        if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
+          const allType = isTypeOnly || names.length > 0 && names.every((n) => typeNames.has(n));
+          addEdge(targetId, edgeTypeFor(allType, names));
+        }
+      }
+    }
+  }
+  for (const nav of parsed.navigations) {
+    if (nav.kind === "window-location") {
+      flagged.push({
+        source: sourceId,
+        target: "EXTERNAL",
+        type: "navigates",
+        label: `window.location to ${nav.target}`,
+        confidence: "high"
+      });
+      continue;
+    }
+    if (!nav.isTemplate) {
+      const targetId = matchRouteToPage(nav.target, routeToNodeId);
+      if (targetId && targetId !== sourceId) {
+        const label = nav.kind === "link-href" ? `Link to ${nav.target}` : `router.${nav.kind === "router-push" ? "push" : "replace"}('${nav.target}')`;
+        addEdge(targetId, "navigates", label);
+      }
+    } else {
+      const template = nav.target.replace(/^`|`$/g, "");
+      if (!template.includes("${")) continue;
+      const targetId = resolveTemplateLiteralRoute(template, routeToNodeId);
+      if (targetId && targetId !== sourceId) {
+        const label = nav.kind === "link-href" ? `Link to ${templateToRoute(template)}` : `router.${nav.kind === "router-push" ? "push" : "replace"}('${templateToRoute(template)}')`;
+        addEdge(targetId, "navigates", label);
+      } else {
+        flagged.push({
+          source: sourceId,
+          target: "DYNAMIC",
+          type: "navigates",
+          label: nav.kind === "link-href" ? `Link with template: \`${template}\`` : `router.${nav.kind === "router-push" ? "push" : "replace"} with template: \`${template}\``,
+          confidence: "medium"
+        });
+      }
+    }
+  }
+  return { edges, flagged };
+}
+function detect(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  return paths !== null;
+}
+function generate(rootDir) {
+  const config = loadConfig(rootDir);
+  const paths = resolveProjectPaths(rootDir, config);
+  const srcDir = paths.srcDir;
+  const allDiscovered = [];
+  const discoveredSet = /* @__PURE__ */ new Set();
+  for (const root of paths.srcRoots) {
+    for (const f of walk(root, [".tsx", ".ts"])) {
+      if (!discoveredSet.has(f)) {
+        discoveredSet.add(f);
+        allDiscovered.push(f);
+      }
+    }
+  }
+  for (const conv of paths.conventionFiles) {
+    if (!discoveredSet.has(conv)) {
+      discoveredSet.add(conv);
+      allDiscovered.push(conv);
+    }
+  }
+  const parsedByPath = /* @__PURE__ */ new Map();
+  for (const absPath of allDiscovered) {
+    parsedByPath.set(absPath, parseFileTS(absPath));
+  }
+  const barrelMaps = buildAllBarrelMaps(srcDir, parsedByPath);
+  const uiNodes = [];
+  const apiNodes = [];
+  const nodeIdSet = /* @__PURE__ */ new Set();
+  const routeToNodeId = /* @__PURE__ */ new Map();
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path6.basename)(f).startsWith("index."));
+  for (const absPath of fileSet) {
+    const id = toNodeId(srcDir, rootDir, absPath);
+    const type = classifyType(absPath, id);
+    if (type === "test" || type === "story") continue;
+    const parsed = parsedByPath.get(absPath);
+    const name = parsed.name || nameFromFilename(absPath);
+    const layer = CLASSIFICATION_TO_LAYER[type] ?? "ui";
+    nodeIdSet.add(id);
+    if (layer === "api") {
+      const dbCalls = extractDbCallsTS(absPath);
+      const authWrappers = extractAuthWrappersTS(absPath);
+      const deep = extractDeep(absPath);
+      const mutations = dbCalls.filter((c) => c.isMutation);
+      const mutates = mutations.length > 0;
+      const authStrategy = [...authWrappers];
+      const isServerAction = type === "server-action";
+      const methods = [];
+      if (!isServerAction) {
+        for (const exp of parsed.exports) {
+          if (HTTP_METHODS.has(exp)) methods.push(exp);
+        }
+      }
+      const routePath = isServerAction ? null : filePathToAppRoute(paths.appDir, absPath);
+      const actions = isServerAction ? parsed.exports.filter((e) => !HTTP_METHODS.has(e)) : [];
+      apiNodes.push({
+        id,
+        type: isServerAction ? "server-action" : "endpoint",
+        // For HTTP routes: name = URL path. For Server Actions: name = file id +
+        // exported action names — the callable surface, not a URL.
+        name: isServerAction ? actions.length > 0 ? `${id} (${actions.join(", ")})` : id : routePath,
+        layer: "api",
+        path: routePath,
+        // null for Server Actions
+        methods,
+        handler: id,
+        mutates,
+        ...isServerAction ? { actions } : {},
+        auth: authStrategy.length > 0 ? authStrategy : ["public"],
+        db_models: [...new Set(dbCalls.map((c) => c.model))],
+        db_operations: [...new Set(dbCalls.map((c) => `${c.model}.${c.method}`))],
+        conditions: deep.conditions,
+        variables: deep.variables,
+        responses: deep.responses,
+        params: deep.params,
+        ...deep.effects ? { effects: deep.effects } : {},
+        _dbCalls: dbCalls
+        // temp: used for cross-ref building below
+      });
+    } else {
+      const route = extractRoute(id);
+      const deep = extractDeep(absPath);
+      const dbCalls = extractDbCallsTS(absPath);
+      const authWrappers = type === "page" || type === "layout" ? [...extractAuthWrappersTS(absPath)] : [];
+      uiNodes.push({
+        id,
+        type,
+        name,
+        layer: "ui",
+        route,
+        exports: parsed.exports,
+        elements: deep.elements,
+        stateVars: deep.stateVars,
+        conditions: deep.conditions,
+        variables: deep.variables,
+        ...deep.effects ? { effects: deep.effects } : {},
+        ...authWrappers.length > 0 ? { auth: authWrappers } : {},
+        ...dbCalls.length > 0 ? { _dbCalls: dbCalls } : {}
+      });
+      if (route) {
+        routeToNodeId.set(route, id);
+        const trimmed = route.replace(/\/\*[^/]+\?$/, "");
+        if (trimmed && trimmed !== route && !routeToNodeId.has(trimmed)) {
+          routeToNodeId.set(trimmed, id);
+        }
+      }
+    }
+  }
+  const uiEdges = [];
+  const uiFlagged = [];
+  for (const absPath of fileSet) {
+    const id = toNodeId(srcDir, rootDir, absPath);
+    if (!nodeIdSet.has(id)) continue;
+    const parsed = parsedByPath.get(absPath);
+    const { edges, flagged } = extractEdges(
+      srcDir,
+      rootDir,
+      absPath,
+      id,
+      parsed,
+      nodeIdSet,
+      barrelMaps,
+      routeToNodeId
+    );
+    uiEdges.push(...edges);
+    uiFlagged.push(...flagged);
+  }
+  const layoutsById = /* @__PURE__ */ new Set();
+  for (const n of uiNodes) {
+    if (n.type === "layout") layoutsById.add(n.id);
+  }
+  function findClosestLayout(pageId) {
+    let dir = pageId.replace(/\/page\.tsx$/, "");
+    while (dir.length > 0) {
+      const candidate = `${dir}/layout.tsx`;
+      if (layoutsById.has(candidate)) return candidate;
+      const slash = dir.lastIndexOf("/");
+      if (slash < 0) break;
+      dir = dir.slice(0, slash);
+    }
+    if (layoutsById.has("app/layout.tsx")) return "app/layout.tsx";
+    return null;
+  }
+  for (const n of uiNodes) {
+    if (n.type !== "page") continue;
+    const layoutId = findClosestLayout(n.id);
+    if (layoutId && layoutId !== n.id) {
+      uiEdges.push({ source: layoutId, target: n.id, type: "wraps" });
+    }
+  }
+  const fetchCallEntries = [];
+  for (const absPath of fileSet) {
+    const sourceId = toNodeId(srcDir, rootDir, absPath);
+    if (!nodeIdSet.has(sourceId)) continue;
+    const parsed = parsedByPath.get(absPath);
+    if (parsed.fetchCalls.length === 0) continue;
+    fetchCallEntries.push({
+      nodeId: sourceId,
+      calls: parsed.fetchCalls.map((c) => ({
+        url: c.url,
+        method: c.method,
+        isTemplate: c.isTemplate,
+        isConcat: c.isConcat,
+        kind: c.kind
+      }))
+    });
+  }
+  const externalScanned = new Set(allDiscovered.map((f) => f.replace(/\\/g, "/")));
+  const 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;
+    let parsed;
+    try {
+      parsed = parseFileTS(absPath);
+    } catch {
+      continue;
+    }
+    const externalId = (0, import_node_path6.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const edgesFromThis = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const imp of parsed.imports) {
+      const { specifier, names } = imp;
+      let resolved = null;
+      if (specifier.startsWith("@/")) {
+        const relToSrc = specifier.slice(2);
+        const barrelMap = barrelMaps.get(relToSrc);
+        if (barrelMap && names.length > 0) {
+          for (const name of names) {
+            const targetAbs = barrelMap.get(name);
+            if (!targetAbs) continue;
+            const targetId2 = toNodeId(srcDir, rootDir, targetAbs);
+            if (!nodeIdSet.has(targetId2)) continue;
+            const key2 = `${externalId}\u2192${targetId2}`;
+            if (seen.has(key2)) continue;
+            seen.add(key2);
+            edgesFromThis.push({ source: externalId, target: targetId2, type: "imports" });
+          }
+          continue;
+        }
+        resolved = resolveImport(srcDir, specifier);
+      } else if (specifier.startsWith(".")) {
+        resolved = resolveRelativeImport(absPath, specifier);
+      }
+      if (!resolved) continue;
+      const targetId = toNodeId(srcDir, rootDir, resolved);
+      if (!nodeIdSet.has(targetId)) continue;
+      if (targetId.endsWith("/index.ts") || targetId.endsWith("/index.tsx")) continue;
+      const key = `${externalId}\u2192${targetId}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edgesFromThis.push({ source: externalId, target: targetId, type: "imports" });
+    }
+    if (edgesFromThis.length === 0) continue;
+    uiNodes.push({
+      id: externalId,
+      type: "external",
+      name: parsed.name || nameFromFilename(absPath),
+      layer: "ui",
+      route: null,
+      exports: parsed.exports
+    });
+    nodeIdSet.add(externalId);
+    uiEdges.push(...edgesFromThis);
+  }
+  const tablesByFile = /* @__PURE__ */ new Map();
+  const allDbNodes = [...apiNodes, ...uiNodes];
+  for (const node of allDbNodes) {
+    const calls = node._dbCalls;
+    if (!calls || calls.length === 0) continue;
+    const map = /* @__PURE__ */ new Map();
+    for (const c of calls) {
+      const key = `${c.kind}:${c.model}:${c.isMutation ? "m" : "r"}`;
+      if (!map.has(key)) {
+        map.set(key, { model: c.model, method: c.method, isMutation: c.isMutation, kind: c.kind, via: [] });
+      }
+    }
+    tablesByFile.set(node.id, map);
+  }
+  const reverseRuntimeImports = /* @__PURE__ */ new Map();
+  for (const edge of uiEdges) {
+    if (edge.type !== "imports" && edge.type !== "renders") continue;
+    if (!reverseRuntimeImports.has(edge.target)) {
+      reverseRuntimeImports.set(edge.target, /* @__PURE__ */ new Set());
+    }
+    reverseRuntimeImports.get(edge.target).add(edge.source);
+  }
+  let changed = true;
+  let iterations = 0;
+  while (changed && iterations < 50) {
+    changed = false;
+    iterations++;
+    for (const [target, tableMap] of [...tablesByFile]) {
+      const importers = reverseRuntimeImports.get(target);
+      if (!importers) continue;
+      for (const importer of importers) {
+        if (importer === target) continue;
+        let importerMap = tablesByFile.get(importer);
+        if (!importerMap) {
+          importerMap = /* @__PURE__ */ new Map();
+          tablesByFile.set(importer, importerMap);
+        }
+        for (const [key, call] of tableMap) {
+          if (importerMap.has(key)) continue;
+          importerMap.set(key, {
+            model: call.model,
+            method: null,
+            isMutation: call.isMutation,
+            kind: call.kind,
+            via: [...call.via, target]
+          });
+          changed = true;
+        }
+      }
+    }
+  }
+  for (const node of apiNodes) {
+    const map = tablesByFile.get(node.id);
+    if (!map) continue;
+    node.db_models = [...new Set([...map.values()].map((c) => c.model))];
+    node.db_operations = [...new Set(
+      [...map.values()].filter((c) => c.via.length === 0 && c.method).map((c) => `${c.model}.${c.method}`)
+    )];
+    node.mutates = [...map.values()].some((c) => c.isMutation);
+  }
+  const apiCrossRefs = [];
+  for (const node of apiNodes) {
+    const map = tablesByFile.get(node.id);
+    if (!map) {
+      delete node._dbCalls;
+      continue;
+    }
+    const seenTargets = /* @__PURE__ */ new Set();
+    for (const call of map.values()) {
+      const target = call.kind === "sql" ? call.model : camelToPascal(call.model);
+      if (seenTargets.has(target)) continue;
+      seenTargets.add(target);
+      const isTransitive = call.via.length > 0;
+      const ref = {
+        source: node.id,
+        target,
+        type: call.isMutation ? isTransitive ? "mutates_via" : "mutates" : isTransitive ? "reads_via" : "reads",
+        layer: "db"
+      };
+      if (isTransitive) ref.via = call.via;
+      apiCrossRefs.push(ref);
+    }
+    delete node._dbCalls;
+  }
+  const uiCrossRefs = [];
+  for (const node of uiNodes) {
+    const map = tablesByFile.get(node.id);
+    if (!map) {
+      if (node._dbCalls) delete node._dbCalls;
+      continue;
+    }
+    const seenTargets = /* @__PURE__ */ new Set();
+    for (const call of map.values()) {
+      const target = call.kind === "sql" ? call.model : camelToPascal(call.model);
+      if (seenTargets.has(target)) continue;
+      seenTargets.add(target);
+      const isTransitive = call.via.length > 0;
+      const ref = {
+        source: node.id,
+        target,
+        type: call.isMutation ? isTransitive ? "mutates_via" : "mutates" : isTransitive ? "reads_via" : "reads",
+        layer: "db"
+      };
+      if (isTransitive) ref.via = call.via;
+      uiCrossRefs.push(ref);
+    }
+    if (node._dbCalls) delete node._dbCalls;
+  }
+  uiCrossRefs.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  const middlewareInfos = [];
+  for (const conv of paths.conventionFiles) {
+    if (!/middleware\.tsx?$/.test(conv)) continue;
+    try {
+      const info = extractMiddlewareAuthTS(conv);
+      if (info && info.matchers.length > 0) middlewareInfos.push(info);
+    } catch {
+    }
+  }
+  if (middlewareInfos.length > 0) {
+    let setAuth2 = function(node, newTags, replaceAll) {
+      const existing = node.auth ?? [];
+      const meaningful = existing.filter((a) => a !== "public");
+      const merged = replaceAll ? newTags : [.../* @__PURE__ */ new Set([...newTags, ...meaningful])];
+      node.auth = merged.length > 0 ? merged : ["public"];
+    }, applyMiddleware2 = function(node, routePath) {
+      let resolved = null;
+      let label = "";
+      let hasAnyExemptMatcher = false;
+      let hasAnyFallthrough = false;
+      for (const info of middlewareInfos) {
+        if (info.hasFallthroughProtect) hasAnyFallthrough = true;
+        if (info.matchers.some((m) => m.intent === "exempt")) hasAnyExemptMatcher = true;
+        const c = classifyRouteAgainstMiddleware(routePath, info);
+        if (!c) continue;
+        if (!resolved) {
+          resolved = c.intent;
+          label = c.matcher;
+        }
+      }
+      if (resolved === "exempt") {
+        setAuth2(node, ["public"], true);
+        return;
+      }
+      if (resolved === "protect") {
+        setAuth2(node, [`middleware:${label}`], false);
+        return;
+      }
+      if (hasAnyExemptMatcher && hasAnyFallthrough) {
+        setAuth2(node, ["middleware-protected"], false);
+      }
+    };
+    var setAuth = setAuth2, applyMiddleware = applyMiddleware2;
+    for (const node of apiNodes) {
+      const routePath = node.path;
+      if (!routePath) continue;
+      applyMiddleware2(node, routePath);
+    }
+    for (const node of uiNodes) {
+      const route = node.route;
+      if (!route) continue;
+      applyMiddleware2(node, route);
+    }
+  }
+  const apiNodeIds = new Set(apiNodes.map((n) => n.id));
+  const apiEdges = [];
+  const uiOnlyEdges = [];
+  for (const edge of uiEdges) {
+    if (apiNodeIds.has(edge.source)) {
+      apiEdges.push(edge);
+    } else {
+      uiOnlyEdges.push(edge);
+    }
+  }
+  const flaggedSet = /* @__PURE__ */ new Set();
+  const dedupedFlagged = uiFlagged.filter((f) => {
+    const key = `${f.source}\u2192${f.target}\u2192${f.label}`;
+    if (flaggedSet.has(key)) return false;
+    flaggedSet.add(key);
+    return true;
+  });
+  const typePriority = {
+    layout: 0,
+    page: 1,
+    component: 2,
+    ui: 3,
+    context: 4,
+    config: 5,
+    util: 6,
+    hook: 7,
+    lib: 8
+  };
+  uiNodes.sort((a, b) => (typePriority[a.type] ?? 99) - (typePriority[b.type] ?? 99) || a.id.localeCompare(b.id));
+  uiOnlyEdges.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  apiNodes.sort((a, b) => (a.path ?? "").localeCompare(b.path ?? ""));
+  apiCrossRefs.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  const byType = (t) => uiNodes.filter((n) => n.type === t).length;
+  const uiStats = {
+    total_pages: byType("page"),
+    total_layouts: byType("layout"),
+    total_components: byType("component"),
+    total_ui: byType("ui"),
+    total_hooks: byType("hook"),
+    total_contexts: byType("context"),
+    total_configs: byType("config"),
+    total_utils: byType("util"),
+    total_libs: byType("lib"),
+    total_external: byType("external"),
+    total_edges: uiOnlyEdges.length,
+    total_flagged: dedupedFlagged.length
+  };
+  const stripLayer = (nodes) => nodes.map(({ layer: _, ...rest }) => rest);
+  const result = /* @__PURE__ */ new Map();
+  result.set("ui", {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "main-app-only",
+      app_root: "src/",
+      layer: "ui",
+      parser: "typescript-project",
+      ...uiStats,
+      notes: "Auto-generated via TypeScript AST \u2014 edges derived from actual imports, renders from JSX usage, navigations from router/Link calls."
+    },
+    nodes: stripLayer(uiNodes),
+    edges: uiOnlyEdges,
+    cross_refs: uiCrossRefs,
+    contradictions: [],
+    warnings: [],
+    flagged_edges: dedupedFlagged,
+    patterns: {
+      total_nodes: uiNodes.length,
+      by_type: uiStats,
+      by_edge_type: {
+        renders: uiOnlyEdges.filter((e) => e.type === "renders").length,
+        imports: uiOnlyEdges.filter((e) => e.type === "imports").length,
+        navigates: uiOnlyEdges.filter((e) => e.type === "navigates").length
+      },
+      fetch_calls: fetchCallEntries
+    }
+  });
+  if (apiNodes.length > 0) {
+    const mutatorNodes = apiNodes.filter((n) => n.mutates).length;
+    const readOnlyNodes = apiNodes.filter((n) => !n.mutates).length;
+    const authUsage = {};
+    let endpointsWithAuth = 0;
+    for (const n of apiNodes) {
+      const auth = n.auth;
+      if (auth.length > 0 && auth[0] !== "public") {
+        endpointsWithAuth++;
+        for (const w of auth) {
+          authUsage[w] = (authUsage[w] ?? 0) + 1;
+        }
+      }
+    }
+    const mutatorCount = {};
+    for (const n of apiNodes) {
+      const ops = n.db_operations;
+      for (const op of ops) {
+        const method = op.split(".")[1];
+        if (method) mutatorCount[method] = (mutatorCount[method] ?? 0) + 1;
+      }
+    }
+    result.set("api", {
+      metadata: {
+        generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+        scope: "main-app-only",
+        stack: "nextjs-app-router",
+        layer: "api",
+        parser: "typescript-project",
+        total_endpoints: apiNodes.length,
+        total_methods: apiNodes.reduce((sum, n) => sum + n.methods.length, 0),
+        endpoints_with_auth: endpointsWithAuth,
+        endpoints_with_db_access: apiNodes.filter((n) => n.db_models.length > 0).length,
+        mutator_endpoints: mutatorNodes,
+        read_only_endpoints: readOnlyNodes
+      },
+      nodes: stripLayer(apiNodes),
+      edges: apiEdges,
+      cross_refs: apiCrossRefs,
+      contradictions: [],
+      warnings: [],
+      flagged_edges: [],
+      patterns: {
+        total_endpoints: apiNodes.length,
+        methods_breakdown: [...HTTP_METHODS].reduce((acc, m) => {
+          acc[m] = apiNodes.filter((n) => n.methods.includes(m)).length;
+          return acc;
+        }, {}),
+        auth_strategies: authUsage,
+        mutation_operations: mutatorCount,
+        mutator_vs_reader: { mutators: mutatorNodes, readers: readOnlyNodes }
+      }
+    });
+  }
+  return result;
+}
+var typescriptProjectParser = {
+  id: "typescript-project",
+  layers: ["ui", "api"],
+  detect,
+  generate
+};
+
+// src/server/graph/parsers/db/prisma-schema.ts
+var import_node_fs7 = require("node:fs");
+function parseModels(content) {
+  const nodes = [];
+  const relations = [];
+  const modelRe = /model\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = modelRe.exec(content)) !== null) {
+    const modelName = m[1];
+    const body = m[2];
+    const columns = [];
+    const lines = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("@@"));
+    for (const line of lines) {
+      const fieldMatch = line.match(/^(\w+)\s+(\S+)(.*)/);
+      if (!fieldMatch) continue;
+      const fieldName = fieldMatch[1];
+      const fieldType = fieldMatch[2];
+      const rest = fieldMatch[3] ?? "";
+      const commentMatch = rest.match(/\/\/\s*(.+)$/);
+      const comment = commentMatch ? commentMatch[1].trim() : null;
+      const restNoComment = commentMatch ? rest.slice(0, commentMatch.index).trim() : rest;
+      const isPrimary = restNoComment.includes("@id");
+      const isUnique = restNoComment.includes("@unique");
+      const isNullable = fieldType.endsWith("?");
+      const baseType = fieldType.replace(/[?\[\]]/g, "");
+      const defaultMatch = restNoComment.match(/@default\(([^)]+)\)/);
+      const defaultVal = defaultMatch ? defaultMatch[1] : null;
+      const relationMatch = restNoComment.match(/@relation\(([^)]*)\)/);
+      const isRelationField = !!relationMatch;
+      columns.push({
+        name: fieldName,
+        type: fieldType,
+        primary: isPrimary,
+        unique: isUnique,
+        nullable: isNullable,
+        default: defaultVal,
+        isRelation: isRelationField,
+        comment
+      });
+      if (relationMatch) {
+        const relArgs = relationMatch[1];
+        const fieldsMatch = relArgs.match(/fields:\s*\[([^\]]+)\]/);
+        const refsMatch = relArgs.match(/references:\s*\[([^\]]+)\]/);
+        const onDeleteMatch = relArgs.match(/onDelete:\s*(\w+)/);
+        if (fieldsMatch && refsMatch) {
+          const fk = fieldsMatch[1].trim();
+          relations.push({
+            source: modelName,
+            target: baseType,
+            type: "belongs_to",
+            fk,
+            onDelete: onDeleteMatch ? onDeleteMatch[1] : null
+          });
+        }
+      }
+      if (fieldType.endsWith("[]") && !relationMatch) {
+        relations.push({
+          source: modelName,
+          target: baseType,
+          type: "has_many",
+          fk: null,
+          onDelete: null
+        });
+      }
+    }
+    nodes.push({
+      id: modelName,
+      type: "table",
+      name: modelName,
+      columns: columns.filter((c) => !c.isRelation || c.primary)
+    });
+  }
+  return { nodes, relations };
+}
+function parseEnums(content) {
+  const nodes = [];
+  const enumRe = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = enumRe.exec(content)) !== null) {
+    const enumName = m[1];
+    const body = m[2];
+    const values = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//"));
+    nodes.push({
+      id: enumName,
+      type: "enum",
+      name: enumName,
+      values
+    });
+  }
+  return nodes;
+}
+function detect2(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  return paths?.dbConfig.kind === "prisma" && (0, import_node_fs7.existsSync)(paths.dbConfig.schemaPath);
+}
+function generate2(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (paths.dbConfig.kind !== "prisma") {
+    return {
+      metadata: { generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), layer: "db", source: "none" },
+      nodes: [],
+      edges: [],
+      cross_refs: [],
+      contradictions: [],
+      warnings: [],
+      flagged_edges: [],
+      patterns: { total_tables: 0, total_enums: 0, total_relations: 0 }
+    };
+  }
+  const schemaPath = paths.dbConfig.schemaPath;
+  const content = (0, import_node_fs7.readFileSync)(schemaPath, "utf-8");
+  const { nodes: modelNodes, relations } = parseModels(content);
+  const enumNodes = parseEnums(content);
+  const allNodes = [...modelNodes, ...enumNodes];
+  const edges = relations.map((r) => ({
+    source: r.source,
+    target: r.target,
+    type: r.type,
+    fk: r.fk,
+    onDelete: r.onDelete
+  }));
+  allNodes.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "table" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  edges.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "prisma-schema",
+      source: schemaPath,
+      provider: "postgresql",
+      layer: "db",
+      total_models: modelNodes.length,
+      total_enums: enumNodes.length,
+      total_relations: edges.length
+    },
+    nodes: allNodes,
+    edges,
+    cross_refs: [],
+    contradictions: [],
+    warnings: [
+      {
+        type: "schema_file_only",
+        detail: "Live DB introspection not yet implemented. Graph derived from prisma/schema.prisma."
+      }
+    ],
+    flagged_edges: [],
+    patterns: {
+      total_tables: modelNodes.length,
+      total_enums: enumNodes.length,
+      total_relations: edges.length,
+      relation_types: {
+        belongs_to: edges.filter((e) => e.type === "belongs_to").length,
+        has_many: edges.filter((e) => e.type === "has_many").length
+      }
+    }
+  };
+}
+var prismaSchemaParser = {
+  id: "prisma-schema",
+  layer: "db",
+  detect: detect2,
+  generate: generate2
+};
+
+// src/server/graph/parsers/db/sql-migrations.ts
+var import_node_fs8 = require("node:fs");
+var import_node_path7 = require("node:path");
+var PG_TO_PRISMA = {
+  "TEXT": "String",
+  "VARCHAR": "String",
+  "CHAR": "String",
+  "INTEGER": "Int",
+  "INT": "Int",
+  "SMALLINT": "Int",
+  "BIGINT": "BigInt",
+  "SERIAL": "Int",
+  "BOOLEAN": "Boolean",
+  "BOOL": "Boolean",
+  "TIMESTAMP(3)": "DateTime",
+  "TIMESTAMP": "DateTime",
+  "TIMESTAMPTZ": "DateTime",
+  "DATE": "DateTime",
+  "DOUBLE PRECISION": "Float",
+  "FLOAT": "Float",
+  "REAL": "Float",
+  "DECIMAL": "Decimal",
+  "NUMERIC": "Decimal",
+  "JSONB": "Json",
+  "JSON": "Json",
+  "BYTEA": "Bytes",
+  "UUID": "String",
+  "TEXT[]": "String[]"
+};
+function pgTypeToPrisma(pgType) {
+  const upper = pgType.toUpperCase().trim();
+  return PG_TO_PRISMA[upper] ?? upper;
+}
+var ID = `(?:"[\\w$]+"|[\\w$]+)`;
+var QID = `(?:${ID}\\.)?${ID}`;
+function bareName(captured) {
+  const parts = captured.split(".");
+  const last = parts[parts.length - 1];
+  return last.replace(/^"(.*)"$/, "$1").trim();
+}
+function parseCreateTable(sql, state) {
+  const re = new RegExp(
+    `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s*\\(([\\s\\S]*?)\\);`,
+    "gi"
+  );
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const tableName = bareName(m[1]);
+    const body = m[2];
+    const columns = /* @__PURE__ */ new Map();
+    let primaryCol = null;
+    const inlineFks = [];
+    const lines = splitTopLevelCommas(body);
+    for (const raw of lines) {
+      const trimmed = raw.trim().replace(/,\s*$/, "");
+      if (!trimmed || trimmed.startsWith("--")) continue;
+      const namedPk = trimmed.match(new RegExp(`^CONSTRAINT\\s+${ID}\\s+PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (namedPk) {
+        primaryCol = bareName(namedPk[1]);
+        continue;
+      }
+      const tablePk = trimmed.match(new RegExp(`^PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
+      if (tablePk) {
+        primaryCol = bareName(tablePk[1]);
+        continue;
+      }
+      if (/^UNIQUE\s*\(/i.test(trimmed)) continue;
+      const namedFk = trimmed.match(new RegExp(
+        `^CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (namedFk) {
+        inlineFks.push({
+          constraintName: bareName(namedFk[1]),
+          sourceTable: tableName,
+          sourceColumn: bareName(namedFk[2]),
+          targetTable: bareName(namedFk[3]),
+          targetColumn: bareName(namedFk[4]),
+          onDelete: namedFk[5] ?? null
+        });
+        continue;
+      }
+      const bareFk = trimmed.match(new RegExp(
+        `^FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (bareFk) {
+        inlineFks.push({
+          constraintName: `${tableName}_${bareName(bareFk[1])}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: bareName(bareFk[1]),
+          targetTable: bareName(bareFk[2]),
+          targetColumn: bareName(bareFk[3]),
+          onDelete: bareFk[4] ?? null
+        });
+        continue;
+      }
+      if (/^CONSTRAINT\s/i.test(trimmed)) continue;
+      const colMatch = trimmed.match(new RegExp(`^(${ID})\\s+(.+)`, "i"));
+      if (!colMatch) continue;
+      const colName = bareName(colMatch[1]);
+      let rest = colMatch[2];
+      const inlineRefMatch = rest.match(new RegExp(
+        `\\bREFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+        "i"
+      ));
+      if (inlineRefMatch) {
+        inlineFks.push({
+          constraintName: `${tableName}_${colName}_fkey`,
+          sourceTable: tableName,
+          sourceColumn: colName,
+          targetTable: bareName(inlineRefMatch[1]),
+          targetColumn: bareName(inlineRefMatch[2]),
+          onDelete: inlineRefMatch[3] ?? null
+        });
+        rest = rest.replace(inlineRefMatch[0], "").trim();
+      }
+      const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
+      const isPrimaryKey = /\bPRIMARY\s+KEY\b/i.test(rest);
+      const isUnique = /\bUNIQUE\b/i.test(rest);
+      const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)(?:\s*,?\s*$)/i);
+      const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
+      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bPRIMARY\s+KEY\b/gi, "").replace(/\bUNIQUE\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
+      columns.set(colName, {
+        name: colName,
+        type: colType,
+        nullable: !isNotNull && !isPrimaryKey,
+        primary: isPrimaryKey,
+        unique: isUnique,
+        default: defaultVal
+      });
+      if (isPrimaryKey) primaryCol = colName;
+    }
+    if (primaryCol && columns.has(primaryCol)) {
+      columns.get(primaryCol).primary = true;
+    }
+    state.tables.set(tableName, { name: tableName, columns });
+    state.fks.push(...inlineFks);
+  }
+}
+function splitTopLevelCommas(body) {
+  const out = [];
+  let depth = 0;
+  let buf = "";
+  let inString = null;
+  for (const ch of body) {
+    if (inString) {
+      buf += ch;
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      inString = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      out.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim()) out.push(buf);
+  return out;
+}
+function parseCreateEnum(sql, state) {
+  const re = new RegExp(
+    `CREATE\\s+TYPE\\s+(${QID})\\s+AS\\s+ENUM\\s*\\(([^)]+)\\)`,
+    "gi"
+  );
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const enumName = bareName(m[1]);
+    const valuesStr = m[2];
+    const values = new Set(
+      valuesStr.split(",").map((v) => v.trim().replace(/^'(.*)'$/, "$1")).filter(Boolean)
+    );
+    state.enums.set(enumName, { name: enumName, values });
+  }
+}
+function parseAlterTable(sql, state) {
+  const addColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+COLUMN\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s+(.+?);`,
+    "gi"
+  );
+  let m;
+  while ((m = addColRe.exec(sql)) !== null) {
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
+    let rest = m[3];
+    const table = state.tables.get(tableName);
+    if (!table) continue;
+    const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
+    const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)$/i);
+    const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
+    let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim();
+    table.columns.set(colName, {
+      name: colName,
+      type: colType,
+      nullable: !isNotNull,
+      primary: false,
+      unique: false,
+      default: defaultVal
+    });
+  }
+  const dropColRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+DROP\\s+COLUMN\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
+  while ((m = dropColRe.exec(sql)) !== null) {
+    const table = state.tables.get(bareName(m[1]));
+    if (table) table.columns.delete(bareName(m[2]));
+  }
+  const fkRe = new RegExp(
+    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
+    "gi"
+  );
+  while ((m = fkRe.exec(sql)) !== null) {
+    state.fks.push({
+      constraintName: bareName(m[2]),
+      sourceTable: bareName(m[1]),
+      sourceColumn: bareName(m[3]),
+      targetTable: bareName(m[4]),
+      targetColumn: bareName(m[5]),
+      onDelete: m[6] ?? null
+    });
+  }
+}
+function parseAlterEnum(sql, state) {
+  const re = new RegExp(
+    `ALTER\\s+TYPE\\s+(${QID})\\s+ADD\\s+VALUE\\s+'([^']+)'`,
+    "gi"
+  );
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const en = state.enums.get(bareName(m[1]));
+    if (en) en.values.add(m[2]);
+  }
+}
+function parseDropTable(sql, state) {
+  const re = new RegExp(
+    `DROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
+    "gi"
+  );
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const dropped = bareName(m[1]);
+    state.tables.delete(dropped);
+    state.fks = state.fks.filter((fk) => fk.sourceTable !== dropped && fk.targetTable !== dropped);
+  }
+}
+function parseUniqueIndex(sql, state) {
+  const re = new RegExp(
+    `CREATE\\s+UNIQUE\\s+INDEX\\s+(?:(?:IF\\s+NOT\\s+EXISTS\\s+)?(?:${ID}\\s+)?)?ON\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)`,
+    "gi"
+  );
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const tableName = bareName(m[1]);
+    const colName = bareName(m[2]);
+    const table = state.tables.get(tableName);
+    const col = table?.columns.get(colName);
+    if (col) col.unique = true;
+    if (!state.uniqueIndexes.has(tableName)) state.uniqueIndexes.set(tableName, /* @__PURE__ */ new Set());
+    state.uniqueIndexes.get(tableName).add(colName);
+  }
+}
+function discoverMigrationFiles(migrationsDir) {
+  if (!(0, import_node_fs8.existsSync)(migrationsDir)) return [];
+  const out = [];
+  const entries = (0, import_node_fs8.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_path7.join)(migrationsDir, entry.name, "migration.sql");
+      if ((0, import_node_fs8.existsSync)(sqlPath)) out.push(sqlPath);
+    } else if (entry.isFile() && entry.name.endsWith(".sql")) {
+      out.push((0, import_node_path7.join)(migrationsDir, entry.name));
+    }
+  }
+  return out;
+}
+function parseMigrations(migrationsDir) {
+  const state = {
+    tables: /* @__PURE__ */ new Map(),
+    enums: /* @__PURE__ */ new Map(),
+    fks: [],
+    uniqueIndexes: /* @__PURE__ */ new Map()
+  };
+  if (!migrationsDir) return state;
+  for (const sqlPath of discoverMigrationFiles(migrationsDir)) {
+    const sql = (0, import_node_fs8.readFileSync)(sqlPath, "utf-8");
+    parseCreateEnum(sql, state);
+    parseCreateTable(sql, state);
+    parseAlterTable(sql, state);
+    parseAlterEnum(sql, state);
+    parseDropTable(sql, state);
+    parseUniqueIndex(sql, state);
+  }
+  return state;
+}
+function loadPrismaState(schemaPath) {
+  if (!schemaPath || !(0, import_node_fs8.existsSync)(schemaPath)) return null;
+  const content = (0, import_node_fs8.readFileSync)(schemaPath, "utf-8");
+  const tables = /* @__PURE__ */ new Map();
+  const enums = /* @__PURE__ */ new Map();
+  const relations = [];
+  const modelRe = /model\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = modelRe.exec(content)) !== null) {
+    const modelName = m[1];
+    const body = m[2];
+    const cols = [];
+    for (const line of body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("@@"))) {
+      const fm = line.match(/^(\w+)\s+(\S+)(.*)/);
+      if (!fm) continue;
+      const fieldName = fm[1];
+      const fieldType = fm[2];
+      const rest = fm[3] ?? "";
+      const baseType = fieldType.replace(/[?\[\]]/g, "");
+      const isRelation = rest.includes("@relation");
+      if (isRelation) {
+        const relArgs = rest.match(/@relation\(([^)]*)\)/)?.[1] ?? "";
+        const fieldsMatch = relArgs.match(/fields:\s*\[([^\]]+)\]/);
+        if (fieldsMatch) {
+          relations.push({ source: modelName, target: baseType, fk: fieldsMatch[1].trim() });
+        }
+        continue;
+      }
+      if (fieldType.endsWith("[]") || fieldType.endsWith("?") && content.includes(`model ${baseType}`)) {
+        if (new RegExp(`model\\s+${baseType}\\s*\\{`).test(content)) continue;
+      }
+      cols.push({
+        name: fieldName,
+        type: fieldType.replace("?", ""),
+        nullable: fieldType.endsWith("?") || fieldType.includes("?"),
+        primary: rest.includes("@id"),
+        unique: rest.includes("@unique")
+      });
+    }
+    tables.set(modelName, { columns: cols });
+  }
+  const enumRe = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+  while ((m = enumRe.exec(content)) !== null) {
+    const values = m[2].split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//"));
+    enums.set(m[1], values);
+  }
+  return { tables, enums, relations };
+}
+function verify(sqlState, prisma) {
+  const contradictions = [];
+  const flaggedEdges = [];
+  for (const [name] of sqlState.tables) {
+    if (!prisma.tables.has(name)) {
+      contradictions.push({
+        entity: name,
+        source_a: "sql-migrations",
+        source_b: "prisma-schema",
+        detail: `Table "${name}" exists in migrations but not in schema.prisma`
+      });
+    }
+  }
+  for (const [name] of prisma.tables) {
+    if (!sqlState.tables.has(name)) {
+      contradictions.push({
+        entity: name,
+        source_a: "prisma-schema",
+        source_b: "sql-migrations",
+        detail: `Table "${name}" in schema.prisma has no CREATE TABLE in migrations`
+      });
+    }
+  }
+  for (const [tableName, prismaTable] of prisma.tables) {
+    const sqlTable = sqlState.tables.get(tableName);
+    if (!sqlTable) continue;
+    for (const prismaCol of prismaTable.columns) {
+      const sqlCol = sqlTable.columns.get(prismaCol.name);
+      if (!sqlCol) {
+        contradictions.push({
+          entity: `${tableName}.${prismaCol.name}`,
+          source_a: "prisma-schema",
+          source_b: "sql-migrations",
+          detail: `Column "${tableName}.${prismaCol.name}" in schema.prisma but not in migrations`
+        });
+        continue;
+      }
+      const mappedSqlType = pgTypeToPrisma(sqlCol.type);
+      const prismaBaseType = prismaCol.type.replace(/[?\[\]]/g, "");
+      if (mappedSqlType !== prismaBaseType && mappedSqlType !== prismaCol.type) {
+        if (!sqlState.enums.has(prismaBaseType)) {
+          contradictions.push({
+            entity: `${tableName}.${prismaCol.name}`,
+            source_a: "sql-migrations",
+            source_b: "prisma-schema",
+            detail: `Column "${tableName}.${prismaCol.name}": SQL type "${sqlCol.type}" (\u2192${mappedSqlType}) vs Prisma type "${prismaCol.type}"`
+          });
+        }
+      }
+      if (sqlCol.nullable !== prismaCol.nullable) {
+        contradictions.push({
+          entity: `${tableName}.${prismaCol.name}`,
+          source_a: "sql-migrations",
+          source_b: "prisma-schema",
+          detail: `Column "${tableName}.${prismaCol.name}": ${sqlCol.nullable ? "nullable" : "NOT NULL"} in SQL vs ${prismaCol.nullable ? "optional" : "required"} in Prisma`
+        });
+      }
+    }
+    for (const [colName] of sqlTable.columns) {
+      const inPrisma = prismaTable.columns.some((c) => c.name === colName);
+      if (!inPrisma) {
+        contradictions.push({
+          entity: `${tableName}.${colName}`,
+          source_a: "sql-migrations",
+          source_b: "prisma-schema",
+          detail: `Column "${tableName}.${colName}" in migrations but not in schema.prisma`
+        });
+      }
+    }
+  }
+  for (const [name, sqlEnum] of sqlState.enums) {
+    const prismaValues = prisma.enums.get(name);
+    if (!prismaValues) {
+      contradictions.push({
+        entity: name,
+        source_a: "sql-migrations",
+        source_b: "prisma-schema",
+        detail: `Enum "${name}" exists in migrations but not in schema.prisma`
+      });
+      continue;
+    }
+    const prismaSet = new Set(prismaValues);
+    for (const val of sqlEnum.values) {
+      if (!prismaSet.has(val)) {
+        contradictions.push({
+          entity: `${name}.${val}`,
+          source_a: "sql-migrations",
+          source_b: "prisma-schema",
+          detail: `Enum "${name}": value "${val}" in migrations but not in schema.prisma`
+        });
+      }
+    }
+    for (const val of prismaValues) {
+      if (!sqlEnum.values.has(val)) {
+        contradictions.push({
+          entity: `${name}.${val}`,
+          source_a: "prisma-schema",
+          source_b: "sql-migrations",
+          detail: `Enum "${name}": value "${val}" in schema.prisma but not in migrations`
+        });
+      }
+    }
+  }
+  const prismaFkSet = new Set(prisma.relations.map((r) => `${r.source}|${r.target}|${r.fk}`));
+  for (const fk of sqlState.fks) {
+    const key = `${fk.sourceTable}|${fk.targetTable}|${fk.sourceColumn}`;
+    if (!prismaFkSet.has(key)) {
+      flaggedEdges.push({
+        source: fk.sourceTable,
+        target: fk.targetTable,
+        type: "belongs_to",
+        label: `FK "${fk.constraintName}" (${fk.sourceColumn}\u2192${fk.targetTable}) in migrations but no @relation in schema.prisma`,
+        confidence: "high"
+      });
+    }
+  }
+  return { contradictions, flaggedEdges };
+}
+function migrationsDirFor(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (!paths) return null;
+  if (paths.dbConfig.kind === "prisma" || paths.dbConfig.kind === "sql-migrations") {
+    return paths.dbConfig.migrationsDir;
+  }
+  return null;
+}
+function schemaPathFor(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (!paths) return null;
+  return paths.dbConfig.kind === "prisma" ? paths.dbConfig.schemaPath : null;
+}
+function detect3(rootDir) {
+  const dir = migrationsDirFor(rootDir);
+  if (!dir) return false;
+  return discoverMigrationFiles(dir).length > 0;
+}
+function generate3(rootDir) {
+  const migrationsDir = migrationsDirFor(rootDir);
+  const sqlState = parseMigrations(migrationsDir);
+  const prisma = loadPrismaState(schemaPathFor(rootDir));
+  const prismaTableIds = prisma ? new Set(prisma.tables.keys()) : /* @__PURE__ */ new Set();
+  const prismaEnumIds = prisma ? new Set(prisma.enums.keys()) : /* @__PURE__ */ new Set();
+  const nodes = [];
+  for (const [name, table] of sqlState.tables) {
+    if (prismaTableIds.has(name)) continue;
+    nodes.push({
+      id: name,
+      type: "table",
+      name,
+      source: "sql",
+      columns: [...table.columns.values()].map((c) => ({
+        name: c.name,
+        type: c.type,
+        primary: c.primary,
+        unique: c.unique,
+        nullable: c.nullable,
+        default: c.default,
+        isRelation: false,
+        comment: null
+      }))
+    });
+  }
+  for (const [name, sqlEnum] of sqlState.enums) {
+    if (prismaEnumIds.has(name)) continue;
+    nodes.push({
+      id: name,
+      type: "enum",
+      name,
+      source: "sql",
+      values: [...sqlEnum.values]
+    });
+  }
+  const sqlOnlyTables = new Set(nodes.filter((n) => n.type === "table").map((n) => n.id));
+  const edges = sqlState.fks.filter((fk) => sqlOnlyTables.has(fk.sourceTable)).map((fk) => ({
+    source: fk.sourceTable,
+    target: fk.targetTable,
+    type: "belongs_to",
+    fk: fk.sourceColumn,
+    onDelete: fk.onDelete
+  }));
+  const { contradictions, flaggedEdges } = prisma ? verify(sqlState, prisma) : { contradictions: [], flaggedEdges: [] };
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "sql-migrations",
+      source: migrationsDir ?? "none",
+      layer: "db",
+      sql_tables: sqlState.tables.size,
+      sql_enums: sqlState.enums.size,
+      sql_fks: sqlState.fks.length,
+      additive_nodes: nodes.length,
+      contradictions_found: contradictions.length,
+      flagged_edges_found: flaggedEdges.length
+    },
+    nodes,
+    edges,
+    cross_refs: [],
+    contradictions,
+    warnings: [],
+    flagged_edges: flaggedEdges
+  };
+}
+var sqlMigrationsParser = {
+  id: "sql-migrations",
+  layer: "db",
+  detect: detect3,
+  generate: generate3
+};
+
+// src/server/graph/core/api-route-matching.ts
+init_launch_kit_paths();
+function loadApiRoutesFromOutput(apiOutput) {
+  const routes = [];
+  for (const n of apiOutput.nodes) {
+    const path = n.path;
+    if (!path || typeof path !== "string") continue;
+    routes.push({
+      path,
+      nodeId: n.id,
+      segments: path.split("/").filter(Boolean)
+    });
+  }
+  return routes;
+}
+function buildApiPathMap(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    if (!map.has(r.path)) map.set(r.path, r.nodeId);
+    const trimmed = r.path.replace(/\/\*[^/]+\?$/, "");
+    if (trimmed && trimmed !== r.path && !map.has(trimmed)) {
+      map.set(trimmed, r.nodeId);
+    }
+  }
+  return map;
+}
+function normalizeFetchUrl(raw) {
+  let s = raw.replace(/^`|`$/g, "");
+  const qIdx = s.indexOf("?");
+  if (qIdx >= 0) s = s.slice(0, qIdx);
+  const hIdx = s.indexOf("#");
+  if (hIdx >= 0) s = s.slice(0, hIdx);
+  let hadInterpolation = false;
+  s = s.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    hadInterpolation = true;
+    const cleaned = expr.trim();
+    const last = cleaned.split(".").pop() ?? cleaned;
+    const name = last.replace(/[^\w]/g, "") || "param";
+    return ":" + name;
+  });
+  s = s.replace(/\/+/g, "/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return { path: s || "/", hadInterpolation };
+}
+function scoreApiRouteMatch(candidate, known) {
+  let score = 0;
+  let i = 0, j = 0;
+  while (i < candidate.length && j < known.length) {
+    const a = candidate[i];
+    const b = known[j];
+    if (b.startsWith("*") && b.endsWith("?")) {
+      score += 1;
+      return score;
+    }
+    if (b.startsWith("*")) {
+      const remaining = candidate.length - i;
+      if (remaining < 1) return -1;
+      score += 1 + remaining;
+      return score;
+    }
+    if (a === b) {
+      score += 3;
+      i++;
+      j++;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      i++;
+      j++;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      score += 1;
+      i++;
+      j++;
+      continue;
+    }
+    return -1;
+  }
+  if (i === candidate.length) {
+    while (j < known.length) {
+      const b = known[j];
+      if (b.startsWith("*") && b.endsWith("?")) {
+        score += 1;
+        j++;
+        continue;
+      }
+      return -1;
+    }
+    return score;
+  }
+  return -1;
+}
+function resolveFetchCall(call, apiPathMap, apiRoutes) {
+  const raw = call.url;
+  if (/^(https?:)?\/\//i.test(raw)) {
+    return { kind: "external", normalizedUrl: raw };
+  }
+  if (call.isConcat) {
+    return { kind: "dynamic", normalizedUrl: raw };
+  }
+  const { path, hadInterpolation } = normalizeFetchUrl(raw);
+  if (!path.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path };
+  }
+  const segs = path.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path };
+  }
+  const exact = apiPathMap.get(path);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path };
+  }
+  return { kind: "unresolved", normalizedUrl: path };
+}
+function resolveUrlPath(urlPath, apiPathMap, apiRoutes) {
+  const { path, hadInterpolation } = normalizeFetchUrl(urlPath);
+  if (!path.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path };
+  }
+  const segs = path.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path };
+  }
+  const exact = apiPathMap.get(path);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path };
+  }
+  return { kind: "unresolved", normalizedUrl: path };
+}
+
+// src/server/graph/parsers/crosslayer/fetch-resolver.ts
+var fetchResolverParser = {
+  id: "fetch-resolver",
+  layer: "crosslayer",
+  concern: "api-binding",
+  detect(_rootDir) {
+    return true;
+  },
+  generate(_rootDir, layerOutputs) {
+    const uiOutput = layerOutputs.get("ui");
+    const apiOutput = layerOutputs.get("api");
+    if (!uiOutput || !apiOutput) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+    const apiPathMap = buildApiPathMap(apiRoutes);
+    const fetchCallEntries = uiOutput.patterns?.fetch_calls ?? [];
+    if (fetchCallEntries.length === 0) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const includeExternal = process.env.LAUNCH_CHART_INCLUDE_EXTERNAL_FETCHES === "1";
+    const crossRefs = [];
+    const flaggedEdges = [];
+    const seen = /* @__PURE__ */ new Set();
+    let resolvedCount = 0;
+    let dynamicCount = 0;
+    let unresolvedCount = 0;
+    let externalCount = 0;
+    for (const entry of fetchCallEntries) {
+      for (const call of entry.calls) {
+        const result = resolveFetchCall(call, apiPathMap, apiRoutes);
+        const methodTag = call.method ?? (call.kind === "fetch" ? "GET?" : "?");
+        if (result.kind === "resolved" && result.nodeId) {
+          const key = `${entry.nodeId}\u2192${result.nodeId}\u2192calls_api`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          crossRefs.push({
+            source: entry.nodeId,
+            target: result.nodeId,
+            type: "calls_api",
+            layer: "api"
+          });
+          resolvedCount++;
+          continue;
+        }
+        if (result.kind === "dynamic") {
+          dynamicCount++;
+          flaggedEdges.push({
+            source: entry.nodeId,
+            target: "DYNAMIC",
+            type: "calls_api",
+            label: call.isConcat ? `${methodTag} fetch with concat: ${call.url}` : `${methodTag} fetch with template: ${call.url}`,
+            confidence: call.isConcat ? "low" : "medium"
+          });
+          continue;
+        }
+        if (result.kind === "external") {
+          externalCount++;
+          if (!includeExternal) continue;
+          flaggedEdges.push({
+            source: entry.nodeId,
+            target: "EXTERNAL",
+            type: "calls_external",
+            label: `${methodTag} external fetch: ${call.url}`,
+            confidence: "high"
+          });
+          continue;
+        }
+        unresolvedCount++;
+        flaggedEdges.push({
+          source: entry.nodeId,
+          target: "UNRESOLVED",
+          type: "calls_api",
+          label: `${methodTag} fetch to unknown path: ${result.normalizedUrl}`,
+          confidence: "medium"
+        });
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: flaggedEdges,
+      warnings: [],
+      patterns: {
+        api_call_detection: {
+          resolved: resolvedCount,
+          dynamic: dynamicCount,
+          unresolved: unresolvedCount,
+          external: externalCount
+        }
+      }
+    };
+  }
+};
+
+// src/server/graph/parsers/crosslayer/api-annotations.ts
+var import_node_fs9 = 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 toNodeId2(srcDir, rootDir, absPath) {
+  const relFromSrc = (0, import_node_path8.relative)(srcDir, absPath).replace(/\\/g, "/");
+  if (relFromSrc.startsWith("..")) {
+    return (0, import_node_path8.relative)(rootDir, absPath).replace(/\\/g, "/");
+  }
+  return relFromSrc;
+}
+var apiAnnotationsParser = {
+  id: "api-annotations",
+  layer: "crosslayer",
+  concern: "api-binding",
+  detect(rootDir) {
+    return resolveProjectPaths(rootDir, loadConfig(rootDir)) !== null;
+  },
+  generate(rootDir, layerOutputs) {
+    const apiOutput = layerOutputs.get("api");
+    if (!apiOutput) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+    if (!paths) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const uiOutput = layerOutputs.get("ui");
+    const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
+    const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+    const apiPathMap = buildApiPathMap(apiRoutes);
+    const srcDir = paths.srcDir;
+    const seen = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const root of paths.srcRoots) {
+      for (const f of walk(root, [".ts", ".tsx"])) {
+        if (!seen.has(f)) {
+          seen.add(f);
+          files.push(f);
+        }
+      }
+    }
+    for (const conv of paths.conventionFiles) {
+      if (!seen.has(conv)) {
+        seen.add(conv);
+        files.push(conv);
+      }
+    }
+    const crossRefs = [];
+    const flaggedEdges = [];
+    const seenEdge = /* @__PURE__ */ new Set();
+    for (const absPath of files) {
+      const content = (0, import_node_fs9.readFileSync)(absPath, "utf-8");
+      const sourceId = toNodeId2(srcDir, rootDir, absPath);
+      if (!uiNodeIds.has(sourceId)) continue;
+      let match;
+      API_ANNOTATION_RE.lastIndex = 0;
+      while ((match = API_ANNOTATION_RE.exec(content)) !== null) {
+        const method = match[1];
+        const urlPath = match[2];
+        const result = resolveUrlPath(urlPath, apiPathMap, apiRoutes);
+        if (result.kind === "resolved" && result.nodeId) {
+          const key = `${sourceId}|${result.nodeId}|calls_api`;
+          if (seenEdge.has(key)) continue;
+          seenEdge.add(key);
+          crossRefs.push({
+            source: sourceId,
+            target: result.nodeId,
+            type: "calls_api",
+            layer: "api"
+          });
+        } else {
+          flaggedEdges.push({
+            source: sourceId,
+            target: "UNRESOLVED",
+            type: "annotation_unresolved",
+            label: `@api ${method} ${urlPath} \u2014 no matching API route found`,
+            confidence: "high"
+          });
+        }
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: flaggedEdges,
+      warnings: [],
+      patterns: {
+        annotations_found: crossRefs.length + flaggedEdges.length,
+        annotations_resolved: crossRefs.length,
+        annotations_unresolved: flaggedEdges.length
+      }
+    };
+  }
+};
+
+// src/server/graph/parsers/crosslayer/url-literal-scanner.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path9 = require("node:path");
+var URL_LITERAL_RE = /['"`](\/[a-zA-Z][^'"`\s]*?)['"`]/g;
+function toNodeId3(srcDir, rootDir, absPath) {
+  const relFromSrc = (0, import_node_path9.relative)(srcDir, absPath).replace(/\\/g, "/");
+  if (relFromSrc.startsWith("..")) {
+    return (0, import_node_path9.relative)(rootDir, absPath).replace(/\\/g, "/");
+  }
+  return relFromSrc;
+}
+var urlLiteralScannerParser = {
+  id: "url-literal-scanner",
+  layer: "crosslayer",
+  concern: "api-binding",
+  detect(rootDir) {
+    const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+    return paths !== null;
+  },
+  generate(rootDir, layerOutputs) {
+    const apiOutput = layerOutputs.get("api");
+    if (!apiOutput) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const uiOutput = layerOutputs.get("ui");
+    const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
+    const apiRoutes = loadApiRoutesFromOutput(apiOutput);
+    const apiPathMap = buildApiPathMap(apiRoutes);
+    const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+    const srcDir = paths.srcDir;
+    const seenFile = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const root of paths.srcRoots) {
+      for (const f of walk(root, [".ts", ".tsx"])) {
+        if (!seenFile.has(f)) {
+          seenFile.add(f);
+          files.push(f);
+        }
+      }
+    }
+    for (const conv of paths.conventionFiles) {
+      if (!seenFile.has(conv)) {
+        seenFile.add(conv);
+        files.push(conv);
+      }
+    }
+    const crossRefs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const absPath of files) {
+      const sourceId = toNodeId3(srcDir, rootDir, absPath);
+      if (!uiNodeIds.has(sourceId)) continue;
+      const content = (0, import_node_fs10.readFileSync)(absPath, "utf-8");
+      let match;
+      URL_LITERAL_RE.lastIndex = 0;
+      while ((match = URL_LITERAL_RE.exec(content)) !== null) {
+        const urlPath = match[1];
+        const result = resolveUrlPath(urlPath, apiPathMap, apiRoutes);
+        if (result.kind === "resolved" && result.nodeId) {
+          const key = `${sourceId}|${result.nodeId}|references_api`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          crossRefs.push({
+            source: sourceId,
+            target: result.nodeId,
+            type: "references_api",
+            layer: "api"
+          });
+        }
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: [],
+      warnings: [],
+      patterns: {
+        url_literals_resolved: crossRefs.length
+      }
+    };
+  }
+};
+
+// src/server/graph/parsers/static/static-values.ts
+var import_node_fs11 = require("node:fs");
+var import_node_path10 = require("node:path");
+var parseCode = null;
+function tryLoadTreeSitter() {
+  if (parseCode) return true;
+  try {
+    const extractor = (init_ts_extractor(), __toCommonJS(ts_extractor_exports));
+    if (typeof extractor.parseCodeTS === "function") {
+      parseCode = extractor.parseCodeTS;
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+var SHARED_MODELS = /* @__PURE__ */ new Set(["permission", "role", "tag"]);
+var DB_MODELS = /* @__PURE__ */ new Set(["subscriptionPlan", "providerDefinition", "pipelineMasterTemplate"]);
+function classifyScope(source, model) {
+  if (source.includes("prisma/schema.prisma")) return "shared";
+  if (source.includes("prisma/seed") && model) {
+    if (SHARED_MODELS.has(model)) return "shared";
+    if (DB_MODELS.has(model)) return "db";
+    return "shared";
+  }
+  if (source.startsWith("src/client/") || source.startsWith("src/app/")) return "fe";
+  if (source.startsWith("src/server/")) return "be";
+  if (source.startsWith("src/config/")) return "be";
+  if (source.startsWith("src/lib/")) return "shared";
+  return "shared";
+}
+function extractEnumValues(rootDir) {
+  const nodes = [];
+  const edges = [];
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  const schemaPaths = [];
+  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath) {
+    schemaPaths.push(paths.dbConfig.schemaPath);
+    schemaPaths.push((0, import_node_path10.join)((0, import_node_path10.dirname)(paths.dbConfig.schemaPath), "schema"));
+  } else {
+    schemaPaths.push((0, import_node_path10.join)(rootDir, "prisma", "schema.prisma"));
+    schemaPaths.push((0, import_node_path10.join)(rootDir, "prisma", "schema"));
+  }
+  let content = "";
+  for (const p of schemaPaths) {
+    if ((0, import_node_fs11.existsSync)(p)) {
+      try {
+        const stat = (0, import_node_fs11.statSync)(p);
+        if (stat.isFile()) {
+          content = (0, import_node_fs11.readFileSync)(p, "utf-8");
+        } else if (stat.isDirectory()) {
+          const files = (0, import_node_fs11.readdirSync)(p).filter((f) => f.endsWith(".prisma"));
+          content = files.map((f) => (0, import_node_fs11.readFileSync)((0, import_node_path10.join)(p, f), "utf-8")).join("\n");
+        }
+      } catch {
+        continue;
+      }
+      break;
+    }
+  }
+  if (!content) return { nodes, edges };
+  const enumRe = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = enumRe.exec(content)) !== null) {
+    const enumName = m[1];
+    const body = m[2];
+    const values = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//"));
+    const scope = classifyScope("prisma/schema.prisma");
+    for (const val of values) {
+      const nodeId = `${enumName}.${val}`;
+      nodes.push({
+        id: nodeId,
+        type: "enum_value",
+        name: val,
+        parentEnum: enumName,
+        value: val,
+        scope,
+        source: "prisma/schema.prisma"
+      });
+      edges.push({
+        source: nodeId,
+        target: `enum:${enumName}`,
+        type: "member_of"
+      });
+    }
+    nodes.push({
+      id: `enum:${enumName}`,
+      type: "enum_group",
+      name: enumName,
+      valueCount: values.length,
+      scope,
+      source: "prisma/schema.prisma"
+    });
+  }
+  return { nodes, edges };
+}
+function extractPropsFromObjectNode(node) {
+  const props = {};
+  for (const child of node.namedChildren) {
+    if (child.type !== "pair") continue;
+    const keyNode = child.childForFieldName("key");
+    const valNode = child.childForFieldName("value");
+    if (!keyNode || !valNode) continue;
+    const key = keyNode.type === "property_identifier" ? keyNode.text : keyNode.text.replace(/['"]/g, "");
+    if (valNode.type === "string" || valNode.type === "template_string") {
+      const fragment = valNode.namedChildren.find((c) => c.type === "string_fragment" || c.type === "template_substitution");
+      props[key] = fragment ? fragment.text : valNode.text.replace(/^['"`]|['"`]$/g, "");
+    } else if (valNode.type === "number") {
+      props[key] = valNode.text;
+    } else if (valNode.type === "true" || valNode.type === "false") {
+      props[key] = valNode.text;
+    }
+  }
+  return props;
+}
+function extractStringArrayFromNode(node) {
+  const values = [];
+  for (const child of node.namedChildren) {
+    if (child.type === "string") {
+      const frag = child.namedChildren.find((c) => c.type === "string_fragment");
+      if (frag) values.push(frag.text);
+    }
+  }
+  return values;
+}
+function findArrayDecl(root, varName) {
+  function walk2(node) {
+    if (node.type === "variable_declarator") {
+      const nameNode = node.childForFieldName("name");
+      const valueNode = node.childForFieldName("value");
+      if (nameNode?.text === varName && valueNode?.type === "array") {
+        return valueNode;
+      }
+      if (nameNode?.text === varName && valueNode?.type === "as_expression") {
+        const inner = valueNode.namedChildren.find((c) => c.type === "array");
+        if (inner) return inner;
+      }
+    }
+    for (const child of node.namedChildren) {
+      const found = walk2(child);
+      if (found) return found;
+    }
+    return null;
+  }
+  return walk2(root);
+}
+function extractObjectPropsRegex(objStr) {
+  const props = {};
+  const propRe = /(\w+):\s*['"]([^'"]*)['"]/g;
+  let m;
+  while ((m = propRe.exec(objStr)) !== null) props[m[1]] = m[2];
+  const numRe = /(\w+):\s*(-?\d+(?:\.\d+)?)\s*[,\n}]/g;
+  while ((m = numRe.exec(objStr)) !== null) if (!props[m[1]]) props[m[1]] = m[2];
+  return props;
+}
+function extractStringArrayRegex(arrStr) {
+  return (arrStr.match(/'([^']+)'/g) ?? []).map((s) => s.replace(/'/g, ""));
+}
+function splitArrayObjectsRegex(arrayBody) {
+  const objects = [];
+  let depth = 0;
+  let start = -1;
+  for (let i = 0; i < arrayBody.length; i++) {
+    if (arrayBody[i] === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (arrayBody[i] === "}") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        objects.push(arrayBody.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return objects;
+}
+function detectSeededArrays(content, sourceFile) {
+  const results = [];
+  const forOfRe = /for\s*\(\s*const\s+\w+\s+of\s+(\w+)\s*\)\s*\{/g;
+  let fm;
+  while ((fm = forOfRe.exec(content)) !== null) {
+    const arrayName = fm[1];
+    const lookahead = content.slice(fm.index + fm[0].length, fm.index + fm[0].length + 500);
+    const prismaMatch = lookahead.match(/prisma\.(\w+)\.(create|upsert|update|createMany|findFirst)/);
+    if (!prismaMatch) continue;
+    results.push({ arrayName, prismaModel: prismaMatch[1], sourceFile });
+  }
+  return results;
+}
+function pickIdField(props) {
+  for (const key of ["key", "slug", "id", "name", "templateId"]) {
+    if (props[key]) return props[key];
+  }
+  return null;
+}
+function pickNameField(props) {
+  for (const key of ["name", "slug", "key", "id"]) {
+    if (props[key]) return props[key];
+  }
+  return null;
+}
+function modelToNodeType(model) {
+  return `seed_${model.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "")}`;
+}
+function extractSeedData(rootDir) {
+  const nodes = [];
+  const edges = [];
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  const candidates = [];
+  if (paths?.dbDir) {
+    candidates.push((0, import_node_path10.join)(paths.dbDir, "seed.ts"));
+    candidates.push((0, import_node_path10.join)(paths.dbDir, "seed.js"));
+  } else {
+    candidates.push((0, import_node_path10.join)(rootDir, "prisma", "seed.ts"));
+    candidates.push((0, import_node_path10.join)(rootDir, "prisma", "seed.js"));
+  }
+  const baseRoots = paths?.srcRoots ?? [(0, import_node_path10.join)(rootDir, "src")];
+  for (const root of baseRoots) {
+    candidates.push((0, import_node_path10.join)(root, "server", "lib", "system-tags.ts"));
+  }
+  const seedFiles = candidates.filter((p) => {
+    try {
+      return (0, import_node_fs11.existsSync)(p) && (0, import_node_fs11.statSync)(p).isFile();
+    } catch {
+      return false;
+    }
+  });
+  const useTreeSitter = tryLoadTreeSitter();
+  for (const filePath of seedFiles) {
+    const content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
+    const relPath = (0, import_node_path10.relative)(rootDir, filePath);
+    const seeded = detectSeededArrays(content, relPath);
+    let astRoot = null;
+    if (useTreeSitter && parseCode) {
+      try {
+        const tree = parseCode(content);
+        astRoot = tree.rootNode;
+      } catch {
+      }
+    }
+    for (const { arrayName, prismaModel, sourceFile } of seeded) {
+      const nodeType = modelToNodeType(prismaModel);
+      const scope = classifyScope(sourceFile, prismaModel);
+      if (astRoot) {
+        const arrayNode = findArrayDecl(astRoot, arrayName);
+        if (!arrayNode) continue;
+        for (const child of arrayNode.namedChildren) {
+          if (child.type !== "object") continue;
+          const props = extractPropsFromObjectNode(child);
+          const idVal = pickIdField(props);
+          if (!idVal) continue;
+          const nameVal = pickNameField(props) ?? idVal;
+          const nodeId = `seed:${prismaModel}:${idVal}`;
+          const { scope: _seedScope, ...safeProps } = props;
+          nodes.push({
+            id: nodeId,
+            type: nodeType,
+            name: nameVal,
+            value: idVal,
+            model: prismaModel,
+            ...safeProps,
+            seedScope: _seedScope ?? void 0,
+            // preserve as seedScope
+            scope,
+            source: sourceFile
+          });
+          const permsArrayNode = child.namedChildren.filter((c) => c.type === "pair").find((c) => c.childForFieldName("key")?.text === "permissions");
+          if (permsArrayNode) {
+            const valNode = permsArrayNode.childForFieldName("value");
+            if (valNode?.type === "array") {
+              const permKeys = extractStringArrayFromNode(valNode);
+              for (const pk of permKeys) {
+                if (pk === "*") continue;
+                edges.push({ source: nodeId, target: `seed:permission:${pk}`, type: "grants" });
+              }
+            }
+          }
+        }
+      } else {
+        const constRe = new RegExp(`const\\s+${arrayName}\\s*(?::[^=]+)?=\\s*\\[`, "g");
+        const cm = constRe.exec(content);
+        if (!cm) continue;
+        const bracketStart = cm.index + cm[0].length - 1;
+        let depth = 1, i = bracketStart + 1;
+        while (i < content.length && depth > 0) {
+          if (content[i] === "[") depth++;
+          else if (content[i] === "]") depth--;
+          i++;
+        }
+        if (depth !== 0) continue;
+        const body = content.slice(bracketStart + 1, i - 1);
+        const objects = splitArrayObjectsRegex(body);
+        for (const objStr of objects) {
+          const props = extractObjectPropsRegex(objStr);
+          const idVal = pickIdField(props);
+          if (!idVal) continue;
+          const nameVal = pickNameField(props) ?? idVal;
+          const nodeId = `seed:${prismaModel}:${idVal}`;
+          const { scope: _rScope, ...rSafeProps } = props;
+          nodes.push({
+            id: nodeId,
+            type: nodeType,
+            name: nameVal,
+            value: idVal,
+            model: prismaModel,
+            ...rSafeProps,
+            seedScope: _rScope ?? void 0,
+            scope,
+            source: sourceFile
+          });
+          const permArrayMatch = objStr.match(/permissions:\s*\[([^\]]*)\]/);
+          if (permArrayMatch) {
+            for (const pk of extractStringArrayRegex(permArrayMatch[1])) {
+              if (pk === "*") continue;
+              edges.push({ source: nodeId, target: `seed:permission:${pk}`, type: "grants" });
+            }
+          }
+        }
+      }
+    }
+  }
+  return { nodes, edges };
+}
+function walkDir(dir, exts) {
+  if (!(0, import_node_fs11.existsSync)(dir)) return [];
+  const results = [];
+  for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
+    const full = (0, import_node_path10.join)(dir, entry.name);
+    if (entry.isDirectory()) results.push(...walkDir(full, exts));
+    else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(full);
+  }
+  return results;
+}
+function extractConstants(rootDir) {
+  const nodes = [];
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  const roots = paths?.srcRoots ?? [(0, import_node_path10.join)(rootDir, "src")];
+  const seenFile = /* @__PURE__ */ new Set();
+  const allFiles = [];
+  for (const root of roots) {
+    for (const f of walkDir(root, [".ts", ".tsx"])) {
+      if (!seenFile.has(f)) {
+        seenFile.add(f);
+        allFiles.push(f);
+      }
+    }
+  }
+  if (allFiles.length === 0) return { nodes };
+  for (const filePath of allFiles) {
+    const content = (0, import_node_fs11.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) {
+      const constName = cm[1];
+      const bracketStart = cm.index + cm[0].length - 1;
+      let depth = 1, i = bracketStart + 1;
+      while (i < content.length && depth > 0) {
+        if (content[i] === "[") depth++;
+        else if (content[i] === "]") depth--;
+        i++;
+      }
+      if (depth !== 0) continue;
+      const body = content.slice(bracketStart + 1, i - 1);
+      const stringValues = extractStringArrayRegex(body);
+      const objectCount = splitArrayObjectsRegex(body).length;
+      const valueCount = Math.max(stringValues.length, objectCount);
+      if (valueCount < 2) continue;
+      const scope = classifyScope(relPath);
+      nodes.push({
+        id: `const:${constName}`,
+        type: "constant",
+        name: constName,
+        valueCount,
+        values: stringValues.length > 0 && stringValues.length <= 30 ? stringValues : void 0,
+        scope,
+        source: relPath
+      });
+    }
+  }
+  return { nodes };
+}
+function detect4(rootDir) {
+  const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+  if (paths?.dbConfig.kind === "prisma" && paths.dbConfig.schemaPath && (0, import_node_fs11.existsSync)(paths.dbConfig.schemaPath)) {
+    return true;
+  }
+  if (paths?.dbDir) {
+    if ((0, import_node_fs11.existsSync)((0, import_node_path10.join)(paths.dbDir, "seed.ts")) || (0, import_node_fs11.existsSync)((0, import_node_path10.join)(paths.dbDir, "seed.js"))) return true;
+  }
+  return (0, import_node_fs11.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "schema.prisma")) || (0, import_node_fs11.existsSync)((0, import_node_path10.join)(rootDir, "prisma", "seed.ts"));
+}
+function generate4(rootDir) {
+  const enumResult = extractEnumValues(rootDir);
+  const seedResult = extractSeedData(rootDir);
+  const constResult = extractConstants(rootDir);
+  const allNodes = [...enumResult.nodes, ...seedResult.nodes, ...constResult.nodes];
+  const allEdges = [...enumResult.edges, ...seedResult.edges];
+  const typeOrder = {
+    enum_group: 0,
+    enum_value: 1,
+    seed_permission: 2,
+    seed_role: 3,
+    seed_tag: 4,
+    seed_plan: 5,
+    seed_provider: 6,
+    constant: 7
+  };
+  allNodes.sort((a, b) => {
+    const ta = typeOrder[a.type] ?? 8;
+    const tb = typeOrder[b.type] ?? 8;
+    if (ta !== tb) return ta - tb;
+    return a.name.localeCompare(b.name);
+  });
+  const enumGroups = allNodes.filter((n) => n.type === "enum_group").length;
+  const enumValues = allNodes.filter((n) => n.type === "enum_value").length;
+  const seedNodes = allNodes.filter((n) => n.type.startsWith("seed_")).length;
+  const constNodes = allNodes.filter((n) => n.type === "constant").length;
+  const byScope = {};
+  for (const n of allNodes) {
+    const s = n.scope ?? "unknown";
+    byScope[s] = (byScope[s] ?? 0) + 1;
+  }
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "static-values",
+      layer: "static",
+      enum_groups: enumGroups,
+      enum_values: enumValues,
+      seed_records: seedNodes,
+      constants: constNodes,
+      total_nodes: allNodes.length,
+      total_edges: allEdges.length,
+      parser: tryLoadTreeSitter() ? "tree-sitter" : "regex-fallback"
+    },
+    nodes: allNodes,
+    edges: allEdges,
+    cross_refs: [],
+    contradictions: [],
+    warnings: [],
+    flagged_edges: [],
+    patterns: {
+      by_type: {
+        enum_group: enumGroups,
+        enum_value: enumValues,
+        seed_permission: allNodes.filter((n) => n.type === "seed_permission").length,
+        seed_role: allNodes.filter((n) => n.type === "seed_role").length,
+        seed_tag: allNodes.filter((n) => n.type === "seed_tag").length,
+        seed_plan: allNodes.filter((n) => n.type === "seed_plan").length,
+        seed_provider: allNodes.filter((n) => n.type === "seed_provider").length,
+        constant: constNodes
+      },
+      by_scope: byScope
+    }
+  };
+}
+var staticValuesParser = {
+  id: "static-values",
+  layer: "static",
+  detect: detect4,
+  generate: generate4
+};
+
+// src/server/graph/parsers/crosslayer/static-ref-scanner.ts
+var import_node_fs12 = require("node:fs");
+var import_node_path11 = require("node:path");
+var MIN_VALUE_LENGTH = 4;
+var SKIP_VALUES = /* @__PURE__ */ new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "none",
+  "default",
+  "name",
+  "type",
+  "data",
+  "text",
+  "info",
+  "error",
+  "open",
+  "read",
+  "user",
+  "test",
+  "json",
+  "form"
+]);
+function isInCommentOrType(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "comment" || current.type === "type_annotation" || current.type === "type_alias_declaration" || current.type === "interface_declaration" || current.type === "jsdoc") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function collectStaticRefs(root, valueLookup) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (node.type === "string_fragment") {
+      const val = node.text;
+      if (val.length >= MIN_VALUE_LENGTH && !SKIP_VALUES.has(val.toLowerCase())) {
+        const targets = valueLookup.get(val);
+        if (targets && !isInCommentOrType(node)) {
+          for (const t of targets) {
+            const key = t;
+            if (!seen.has(key)) {
+              seen.add(key);
+              refs.push({ value: val, targetIds: [t] });
+            }
+          }
+        }
+      }
+    }
+    if (node.type === "member_expression") {
+      const objNode = node.namedChildren.find((c) => c.type === "identifier");
+      const propNode = node.namedChildren.find((c) => c.type === "property_identifier");
+      if (objNode && propNode) {
+        const combined = `${objNode.text}.${propNode.text}`;
+        const targets = valueLookup.get(propNode.text);
+        const directTarget = valueLookup.get(combined);
+        if (directTarget && !isInCommentOrType(node)) {
+          for (const t of directTarget) {
+            if (!seen.has(t)) {
+              seen.add(t);
+              refs.push({ value: combined, targetIds: [t] });
+            }
+          }
+        } else if (targets && !isInCommentOrType(node)) {
+          for (const t of targets) {
+            if (!seen.has(t)) {
+              seen.add(t);
+              refs.push({ value: propNode.text, targetIds: [t] });
+            }
+          }
+        }
+      }
+    }
+    for (const child of node.namedChildren) {
+      visit(child);
+    }
+  }
+  visit(root);
+  return refs;
+}
+function collectStaticRefsRegex(content, valueLookup, allValues) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const escaped = allValues.map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const pattern = new RegExp(
+    `(?:['"\`])(${escaped.join("|")})(?:['"\`])|\\b(\\w+)\\.(${escaped.join("|")})\\b`,
+    "g"
+  );
+  let match;
+  pattern.lastIndex = 0;
+  while ((match = pattern.exec(content)) !== null) {
+    const val = match[1] ?? match[3];
+    if (!val) continue;
+    const targets = valueLookup.get(val);
+    if (!targets) continue;
+    for (const t of targets) {
+      if (!seen.has(t)) {
+        seen.add(t);
+        refs.push({ value: val, targetIds: [t] });
+      }
+    }
+  }
+  return refs;
+}
+var staticRefScannerParser = {
+  id: "static-ref-scanner",
+  layer: "crosslayer",
+  concern: "static-ref",
+  detect(rootDir) {
+    const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+    return paths !== null;
+  },
+  generate(rootDir, layerOutputs) {
+    const staticOutput = layerOutputs.get("static");
+    if (!staticOutput || !Array.isArray(staticOutput.nodes) || staticOutput.nodes.length === 0) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const valueLookup = /* @__PURE__ */ new Map();
+    for (const node of staticOutput.nodes) {
+      const type = node.type;
+      let valueStr = null;
+      if (type === "enum_value") {
+        valueStr = node.value;
+        const fullId = node.id;
+        if (!valueLookup.has(fullId)) valueLookup.set(fullId, []);
+        valueLookup.get(fullId).push(node.id);
+      } else if (type.startsWith("seed_")) {
+        valueStr = node.value;
+      }
+      if (!valueStr || valueStr.length < MIN_VALUE_LENGTH || SKIP_VALUES.has(valueStr.toLowerCase())) continue;
+      if (!valueLookup.has(valueStr)) valueLookup.set(valueStr, []);
+      valueLookup.get(valueStr).push(node.id);
+    }
+    const allValues = [...valueLookup.keys()].sort((a, b) => b.length - a.length);
+    if (allValues.length === 0) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+    if (!paths) return { cross_refs: [], flagged_edges: [], warnings: [] };
+    const srcDir = paths.srcDir;
+    const seenFile = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const root of paths.srcRoots) {
+      for (const f of walkWithIgnore(root, [".ts", ".tsx"])) {
+        if (!seenFile.has(f)) {
+          seenFile.add(f);
+          files.push(f);
+        }
+      }
+    }
+    for (const conv of paths.conventionFiles) {
+      if (!seenFile.has(conv)) {
+        seenFile.add(conv);
+        files.push(conv);
+      }
+    }
+    const uiOutput = layerOutputs.get("ui");
+    const apiOutput = layerOutputs.get("api");
+    const uiNodeIds = new Set(uiOutput?.nodes.map((n) => n.id) ?? []);
+    const apiNodeIds = new Set(apiOutput?.nodes.map((n) => n.id) ?? []);
+    let parseCode2 = null;
+    try {
+      const extractor = (init_ts_extractor(), __toCommonJS(ts_extractor_exports));
+      if (typeof extractor.parseCodeTS === "function") {
+        parseCode2 = extractor.parseCodeTS;
+      }
+    } catch {
+    }
+    const crossRefs = [];
+    const seen = /* @__PURE__ */ new Set();
+    let filesScanned = 0;
+    for (const absPath of files) {
+      const relFromSrc = (0, import_node_path11.relative)(srcDir, absPath).replace(/\\/g, "/");
+      const sourceId = relFromSrc.startsWith("..") ? (0, import_node_path11.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_fs12.readFileSync)(absPath, "utf-8");
+      filesScanned++;
+      let fileRefs;
+      if (parseCode2) {
+        try {
+          const tree = parseCode2(content);
+          fileRefs = collectStaticRefs(tree.rootNode, valueLookup);
+        } catch {
+          fileRefs = collectStaticRefsRegex(content, valueLookup, allValues);
+        }
+      } else {
+        fileRefs = collectStaticRefsRegex(content, valueLookup, allValues);
+      }
+      for (const ref of fileRefs) {
+        for (const targetId of ref.targetIds) {
+          const key = `${sourceId}|${targetId}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          crossRefs.push({
+            source: sourceId,
+            target: targetId,
+            type: "references_static",
+            layer: "static"
+          });
+        }
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: [],
+      warnings: [],
+      patterns: {
+        files_scanned: filesScanned,
+        static_values_tracked: valueLookup.size,
+        references_found: crossRefs.length,
+        parser: parseCode2 ? "tree-sitter" : "regex-fallback"
+      }
+    };
+  }
+};
+
+// src/server/graph/parsers/crosslayer/middleware-gates.ts
+var import_node_path12 = require("node:path");
+init_ts_extractor();
+function toNodeId4(srcDir, rootDir, absPath) {
+  const relFromSrc = (0, import_node_path12.relative)(srcDir, absPath).replace(/\\/g, "/");
+  if (relFromSrc.startsWith("..")) {
+    return (0, import_node_path12.relative)(rootDir, absPath).replace(/\\/g, "/");
+  }
+  return relFromSrc;
+}
+function collectTargets(apiOutput, uiOutput) {
+  const out = [];
+  for (const n of apiOutput?.nodes ?? []) {
+    if (n.type !== "endpoint") continue;
+    const path = n.path;
+    if (typeof path !== "string" || !path) continue;
+    out.push({ id: n.id, route: path, layer: "api" });
+  }
+  for (const n of uiOutput?.nodes ?? []) {
+    if (n.type !== "page") continue;
+    const route = n.route;
+    if (typeof route !== "string" || !route) continue;
+    out.push({ id: n.id, route, layer: "ui" });
+  }
+  return out;
+}
+var middlewareGatesParser = {
+  id: "middleware-gates",
+  layer: "crosslayer",
+  concern: "auth-gate",
+  detect(rootDir) {
+    const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+    if (!paths) return false;
+    return paths.conventionFiles.some((f) => /middleware\.tsx?$/.test(f));
+  },
+  generate(rootDir, layerOutputs) {
+    const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
+    if (!paths) return { cross_refs: [], flagged_edges: [], warnings: [] };
+    const middlewareFiles = paths.conventionFiles.filter((f) => /middleware\.tsx?$/.test(f));
+    if (middlewareFiles.length === 0) {
+      return { cross_refs: [], flagged_edges: [], warnings: [] };
+    }
+    const apiOutput = layerOutputs.get("api");
+    const uiOutput = layerOutputs.get("ui");
+    const targets = collectTargets(apiOutput, uiOutput);
+    const crossRefs = [];
+    const flagged = [];
+    const seenEdge = /* @__PURE__ */ new Set();
+    const seenUnparseable = /* @__PURE__ */ new Set();
+    let protectMatcherCount = 0;
+    for (const file of middlewareFiles) {
+      let info = null;
+      try {
+        info = extractMiddlewareAuthTS(file);
+      } catch {
+      }
+      if (!info || info.matchers.length === 0) continue;
+      const middlewareId = toNodeId4(paths.srcDir, rootDir, file);
+      for (const matcher of info.matchers) {
+        if (matcher.intent !== "protect") continue;
+        protectMatcherCount += 1;
+        for (const pattern of matcher.patterns) {
+          const re = middlewarePatternToRegex(pattern);
+          if (!re) {
+            const key = `${middlewareId}|${pattern}`;
+            if (seenUnparseable.has(key)) continue;
+            seenUnparseable.add(key);
+            flagged.push({
+              source: middlewareId,
+              target: "UNRESOLVED",
+              type: "middleware_pattern_unparseable",
+              label: `pattern "${pattern}" in matcher "${matcher.name}" \u2014 coverage unknown`,
+              confidence: "high"
+            });
+            continue;
+          }
+          for (const target of targets) {
+            if (!re.test(target.route)) continue;
+            const key = `${middlewareId}|${target.id}|protects`;
+            if (seenEdge.has(key)) continue;
+            seenEdge.add(key);
+            crossRefs.push({
+              source: middlewareId,
+              target: target.id,
+              type: "protects",
+              layer: target.layer
+            });
+          }
+        }
+      }
+    }
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: flagged,
+      warnings: [],
+      patterns: {
+        middleware_files: middlewareFiles.length,
+        protect_matchers: protectMatcherCount,
+        protects_edges: crossRefs.length,
+        unparseable_patterns: flagged.length
+      }
+    };
+  }
+};
+
+// src/server/graph/core/parser-registry.ts
+function isMultiLayerParser(p) {
+  return "layers" in p && Array.isArray(p.layers);
+}
+var ParserRegistry = class {
+  constructor() {
+    this.singleLayerParsers = /* @__PURE__ */ new Map();
+    this.multiLayerParsers = [];
+    this.ids = /* @__PURE__ */ new Set();
+  }
+  register(parser) {
+    if (this.ids.has(parser.id)) {
+      throw new Error(`Duplicate parser id: ${parser.id}`);
+    }
+    this.ids.add(parser.id);
+    if (isMultiLayerParser(parser)) {
+      this.multiLayerParsers.push(parser);
+    } else {
+      const list = this.singleLayerParsers.get(parser.layer) ?? [];
+      list.push(parser);
+      this.singleLayerParsers.set(parser.layer, list);
+    }
+  }
+  /** Get single-layer parsers for a specific layer. */
+  getParsers(layer) {
+    return this.singleLayerParsers.get(layer) ?? [];
+  }
+  /** Get multi-layer parsers that can produce output for the given layer. */
+  getMultiLayerParsersFor(layer) {
+    return this.multiLayerParsers.filter((p) => p.layers.includes(layer));
+  }
+  /** Get all multi-layer parsers. */
+  getMultiLayerParsers() {
+    return [...this.multiLayerParsers];
+  }
+  getCrossLayerParsers() {
+    return this.singleLayerParsers.get("crosslayer") ?? [];
+  }
+  /** All layers that registered parsers can produce (single + multi). */
+  getAvailableLayers() {
+    const layers = /* @__PURE__ */ new Set();
+    for (const key of this.singleLayerParsers.keys()) {
+      if (key !== "crosslayer") layers.add(key);
+    }
+    for (const mp of this.multiLayerParsers) {
+      for (const l of mp.layers) layers.add(l);
+    }
+    return [...layers];
+  }
+  getAll() {
+    const all = [];
+    for (const list of this.singleLayerParsers.values()) all.push(...list);
+    all.push(...this.multiLayerParsers);
+    return all;
+  }
+};
+function registerBuiltins(registry, disabled) {
+  const builtins = [
+    typescriptProjectParser,
+    prismaSchemaParser,
+    sqlMigrationsParser,
+    staticValuesParser,
+    fetchResolverParser,
+    apiAnnotationsParser,
+    urlLiteralScannerParser,
+    staticRefScannerParser,
+    middlewareGatesParser
+  ];
+  for (const parser of builtins) {
+    if (disabled.has(parser.id)) continue;
+    registry.register(parser);
+  }
+}
+function loadCustomParsers(registry, config, rootDir, disabled) {
+  for (const entry of config.parsers?.custom ?? []) {
+    try {
+      const absPath = (0, import_node_path13.resolve)(rootDir, entry.path);
+      const mod = require(absPath);
+      const parser = "default" in mod ? mod.default : mod;
+      if (disabled.has(parser.id)) continue;
+      if (!isMultiLayerParser(parser) && parser.layer !== entry.layer) {
+        process.stderr.write(
+          `[launch-chart] custom parser "${parser.id}" declares layer "${parser.layer}" but config says "${entry.layer}" \u2014 using parser's layer
+`
+        );
+      }
+      if (parser.layer === "crosslayer" && entry.concern && !("concern" in parser && parser.concern)) {
+        parser.concern = entry.concern;
+      }
+      registry.register(parser);
+    } catch (err) {
+      process.stderr.write(`[launch-chart] failed to load custom parser from ${entry.path}: ${err}
+`);
+    }
+  }
+}
+function createRegistry(config, rootDir) {
+  const registry = new ParserRegistry();
+  const disabled = new Set(config.parsers?.disabled ?? []);
+  registerBuiltins(registry, disabled);
+  loadCustomParsers(registry, config, rootDir, disabled);
+  return registry;
+}
+
+// src/server/graph/core/merge.ts
+function mergeGraphOutputs(outputs, layer) {
+  if (outputs.length === 0) {
+    return {
+      metadata: { generated: (/* @__PURE__ */ new Date()).toISOString(), scope: "", layer },
+      nodes: [],
+      edges: [],
+      cross_refs: [],
+      contradictions: [],
+      warnings: [],
+      flagged_edges: []
+    };
+  }
+  if (outputs.length === 1) return outputs[0];
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const seenCrossRefs = /* @__PURE__ */ new Set();
+  const mergedNodes = [];
+  const mergedEdges = [];
+  const mergedCrossRefs = [];
+  const mergedContradictions = [];
+  const mergedWarnings = [];
+  const mergedFlagged = [];
+  const parserIds = [];
+  for (const output of outputs) {
+    if (output.metadata.parser) {
+      parserIds.push(String(output.metadata.parser));
+    }
+    for (const node of output.nodes) {
+      if (seenNodes.has(node.id)) {
+        mergedWarnings.push({
+          type: "merge_conflict",
+          detail: `Node "${node.id}" produced by multiple parsers; keeping first`
+        });
+        continue;
+      }
+      seenNodes.add(node.id);
+      mergedNodes.push(node);
+    }
+    for (const edge of output.edges) {
+      const key = `${edge.source}|${edge.target}|${edge.type}`;
+      if (seenEdges.has(key)) continue;
+      seenEdges.add(key);
+      mergedEdges.push(edge);
+    }
+    for (const ref of output.cross_refs) {
+      const key = `${ref.source}|${ref.target}|${ref.type}`;
+      if (seenCrossRefs.has(key)) continue;
+      seenCrossRefs.add(key);
+      mergedCrossRefs.push(ref);
+    }
+    mergedContradictions.push(...output.contradictions);
+    mergedWarnings.push(...output.warnings);
+    mergedFlagged.push(...output.flagged_edges);
+  }
+  const metadata = {
+    ...outputs[0].metadata,
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    parsers: parserIds
+  };
+  return {
+    metadata,
+    nodes: mergedNodes,
+    edges: mergedEdges,
+    cross_refs: mergedCrossRefs,
+    contradictions: mergedContradictions,
+    warnings: mergedWarnings,
+    flagged_edges: mergedFlagged,
+    patterns: outputs[0].patterns
+  };
+}
+function dedupCrossRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ref of refs) {
+    const key = `${ref.source}|${ref.target}|${ref.type}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(ref);
+  }
+  return result;
+}
+function applyCrossLayerResults(uiOutput, results) {
+  return {
+    ...uiOutput,
+    cross_refs: dedupCrossRefs([
+      ...uiOutput.cross_refs,
+      ...results.flatMap((r) => r.output.cross_refs)
+    ]),
+    flagged_edges: [
+      ...uiOutput.flagged_edges,
+      ...results.flatMap((r) => r.output.flagged_edges)
+    ],
+    warnings: [
+      ...uiOutput.warnings,
+      ...results.flatMap((r) => r.output.warnings)
+    ]
+  };
+}
+
+// src/server/graph/core/graph-builder.ts
+function readGraphFromDisk(rootDir, layer) {
+  const filePath = (0, import_node_path14.join)(rootDir, LAUNCHSECURE_DIR, "graphs", `${layer}.json`);
+  if (!(0, import_node_fs13.existsSync)(filePath)) return null;
+  try {
+    return JSON.parse((0, import_node_fs13.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function generateLayer(rootDir, layer) {
+  const config = loadConfig(rootDir);
+  const registry = createRegistry(config, rootDir);
+  const outputs = [];
+  for (const parser of registry.getParsers(layer)) {
+    if (!parser.detect(rootDir)) continue;
+    outputs.push(parser.generate(rootDir));
+  }
+  for (const mp of registry.getMultiLayerParsersFor(layer)) {
+    if (!mp.detect(rootDir)) continue;
+    const multiOutput = mp.generate(rootDir);
+    const layerOutput = multiOutput.get(layer);
+    if (layerOutput) outputs.push(layerOutput);
+  }
+  if (outputs.length === 0) return null;
+  let merged = outputs.length === 1 ? outputs[0] : mergeGraphOutputs(outputs, layer);
+  if (layer === "ui") {
+    const layerOutputs = /* @__PURE__ */ new Map();
+    layerOutputs.set("ui", merged);
+    for (const otherLayer of registry.getAvailableLayers()) {
+      if (otherLayer === "ui") continue;
+      const existing = readGraphFromDisk(rootDir, otherLayer);
+      if (existing) layerOutputs.set(otherLayer, existing);
+    }
+    const crossParsers = registry.getCrossLayerParsers();
+    const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
+    if (crossResults.length > 0) {
+      merged = applyCrossLayerResults(merged, crossResults);
+    }
+  }
+  return {
+    layer,
+    output: merged,
+    nodeCount: merged.nodes.length,
+    edgeCount: merged.edges.length
+  };
+}
+function generateAll(rootDir) {
+  const config = loadConfig(rootDir);
+  const registry = createRegistry(config, rootDir);
+  const allLayers = registry.getAvailableLayers();
+  const layerOrder = [
+    ...allLayers.filter((l) => l !== "ui"),
+    ...allLayers.filter((l) => l === "ui")
+  ];
+  const layerOutputs = /* @__PURE__ */ new Map();
+  const results = [];
+  const multiLayerResults = /* @__PURE__ */ new Map();
+  for (const layer of layerOrder) {
+    const outputs = [];
+    for (const parser of registry.getParsers(layer)) {
+      if (!parser.detect(rootDir)) continue;
+      outputs.push(parser.generate(rootDir));
+    }
+    for (const mp of registry.getMultiLayerParsersFor(layer)) {
+      if (!mp.detect(rootDir)) continue;
+      if (!multiLayerResults.has(mp.id)) {
+        multiLayerResults.set(mp.id, mp.generate(rootDir));
+      }
+      const cached = multiLayerResults.get(mp.id);
+      const layerOutput = cached.get(layer);
+      if (layerOutput) outputs.push(layerOutput);
+    }
+    if (outputs.length === 0) continue;
+    const merged = outputs.length === 1 ? outputs[0] : mergeGraphOutputs(outputs, layer);
+    layerOutputs.set(layer, merged);
+    results.push({
+      layer,
+      output: merged,
+      nodeCount: merged.nodes.length,
+      edgeCount: merged.edges.length
+    });
+  }
+  const crossParsers = registry.getCrossLayerParsers();
+  const crossResults = crossParsers.filter((p) => p.detect(rootDir)).map((p) => ({ parserId: p.id, output: p.generate(rootDir, layerOutputs) }));
+  if (crossResults.length > 0 && layerOutputs.has("ui")) {
+    const uiOutput = layerOutputs.get("ui");
+    const merged = applyCrossLayerResults(uiOutput, crossResults);
+    layerOutputs.set("ui", merged);
+    const uiResult = results.find((r) => r.layer === "ui");
+    if (uiResult) {
+      uiResult.output = merged;
+      uiResult.nodeCount = merged.nodes.length;
+      uiResult.edgeCount = merged.edges.length;
+    }
+  }
+  const byLayer = new Map(results.map((r) => [r.layer, r]));
+  const wellKnownOrder = ["ui", "api", "db"];
+  const extras = [...byLayer.keys()].filter((l) => !wellKnownOrder.includes(l)).sort();
+  return [...wellKnownOrder, ...extras].map((l) => byLayer.get(l)).filter((r) => !!r);
+}
+
+// src/server/parse-worker-entry.ts
+init_parse_failure_cache();
+init_ts_extractor();
+if (!import_node_worker_threads.parentPort) {
+  throw new Error("parse-worker-entry must be spawned as a worker thread");
+}
+async function run(req) {
+  try {
+    await initTreeSitter();
+    const config = loadConfig(req.rootDir);
+    setExtractorConfig({
+      dbIdentifiers: config.parsers?.patterns?.dbIdentifiers,
+      mutationMethods: config.parsers?.patterns?.mutationMethods
+    });
+    const failureCache = new ParseFailureCache(req.rootDir, getTreeSitterFingerprint());
+    if (!req.layer) failureCache.clearAll();
+    setActiveFailureCache(failureCache);
+    let results;
+    try {
+      results = req.layer ? [generateLayer(req.rootDir, req.layer)].filter((r) => r !== null) : generateAll(req.rootDir);
+    } finally {
+      failureCache.flush();
+      setActiveFailureCache(null);
+    }
+    const failedFiles = failureCache.list().map((f) => f.path);
+    return { ok: true, results, failedFiles };
+  } catch (e) {
+    const err = e instanceof Error ? e : new Error(String(e));
+    return { ok: false, error: { name: err.name, message: err.message, stack: err.stack } };
+  }
+}
+import_node_worker_threads.parentPort.once("message", async (msg) => {
+  const reply = await run(msg);
+  import_node_worker_threads.parentPort.postMessage(reply);
+});