ai-code-map 0.0.0-stage → 0.1.0-alpha.3

package/dist/compiler-worker.js

@@ -0,0 +1,4395 @@
+// src/compiler-worker.ts
+import { Session } from "inspector/promises";
+import { parentPort, workerData } from "worker_threads";
+
+// src/analyze.ts
+import { promises as fs3 } from "fs";
+import path9 from "path";
+import ts8 from "typescript";
+
+// src/constants.ts
+var SCHEMA_VERSION = 4;
+var CONFIG_VERSION = 1;
+var ANALYZER_VERSION = "0.4.0";
+var DEFAULT_OUTPUT = ".ai/code-map";
+var DEFAULT_INCLUDE = [
+  "src/**/*",
+  "app/**/*",
+  "pages/**/*",
+  "lib/**/*",
+  "server/**/*",
+  "*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"
+];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/.git/**",
+  "**/.ai/**",
+  "**/*.generated.*"
+];
+var MAP_COMPANION_ARTIFACTS = [
+  "overview.md",
+  "project.json",
+  "files.jsonl",
+  "symbols.jsonl",
+  "relations.jsonl",
+  "diagnostics.json"
+];
+
+// src/utils/path.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// src/errors.ts
+var CodeMapError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "CodeMapError";
+    this.code = code;
+  }
+};
+
+// src/utils/path.ts
+function isAbsolutePath(value) {
+  const normalized = toPosixPath(value);
+  return path.posix.isAbsolute(normalized) || /^[a-zA-Z]:[\\/]/.test(normalized) || normalized.startsWith("//");
+}
+function isFileSystemUri(value) {
+  return /^file:(?:\/\/|\/)/i.test(value.trim());
+}
+function hasEmbeddedDoubleSlashPath(value) {
+  const normalized = toPosixPath(value);
+  let index = normalized.indexOf("//");
+  while (index >= 0) {
+    const previous = index > 0 ? normalized[index - 1] : void 0;
+    if (previous !== ":") return true;
+    index = normalized.indexOf("//", index + 1);
+  }
+  return false;
+}
+function hasEmbeddedAbsolutePath(value) {
+  const normalized = toPosixPath(value);
+  return isAbsolutePath(normalized) || isFileSystemUri(normalized) || hasEmbeddedDoubleSlashPath(normalized) || /(?:^|\/)[A-Za-z]:(?:\/|$)/.test(normalized) || /(?:^|\/)file:(?:\/|$)/i.test(normalized);
+}
+function isSafeRelativePathPattern(value) {
+  const normalized = toPosixPath(value);
+  return normalized.length > 0 && !hasEmbeddedAbsolutePath(normalized) && !normalized.split("/").includes("..");
+}
+function looksLikeHostFilePath(value, root) {
+  const trimmed = value.trim();
+  if (/file:(?:\/\/|\/)/i.test(trimmed) || /(?:^|[/])[A-Za-z]:[\\/]/.test(trimmed) || /^\\\\/.test(trimmed) || hasEmbeddedDoubleSlashPath(trimmed)) {
+    return true;
+  }
+  const normalized = toPosixPath(trimmed);
+  if (root) {
+    const normalizedRoot = toPosixPath(path.resolve(root));
+    if (normalized === normalizedRoot || normalized.startsWith(`${normalizedRoot}/`) || normalized.includes(normalizedRoot))
+      return true;
+  }
+  return /^\/(?:Users|home|root|private|tmp|var|etc|usr|opt|Volumes|mnt|proc|dev)(?:\/|$)/.test(
+    normalized
+  );
+}
+function toPosixPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function relativePosix(root, absolutePath) {
+  if (!isAbsolutePath(absolutePath)) {
+    throw new CodeMapError(
+      "PATH_OUTSIDE_ROOT",
+      `Path ${absolutePath} is outside project root ${root}.`
+    );
+  }
+  const relative = path.relative(root, absolutePath);
+  if (relative === "" || isRelativeInside(relative)) {
+    return toPosixPath(relative || ".");
+  }
+  throw new CodeMapError(
+    "PATH_OUTSIDE_ROOT",
+    `Path ${absolutePath} is outside project root ${root}.`
+  );
+}
+function isPathInside(root, candidate) {
+  if (isAbsolutePath(candidate) && !path.isAbsolute(candidate)) return false;
+  const relative = path.relative(path.resolve(root), path.resolve(candidate));
+  return relative === "" || isRelativeInside(relative);
+}
+function isRelativeInside(relative) {
+  const normalized = toPosixPath(relative);
+  if (normalized === "" || normalized === ".") return true;
+  if (isAbsolutePath(normalized)) return false;
+  return normalized !== ".." && !normalized.startsWith("../") && !normalized.startsWith("..\\");
+}
+function redactAbsolutePathsInText(message, root) {
+  const normalizedRoot = path.resolve(root);
+  const redact = (candidate) => {
+    const trimmed = candidate.replace(/[)\].,;:]+$/, "");
+    if (!isAbsolutePath(trimmed) && !isFileSystemUri(trimmed)) return candidate;
+    if (isFileSystemUri(trimmed)) return "<outside-root>";
+    const foreignWindowsPath = path.win32.isAbsolute(trimmed) && !path.posix.isAbsolute(trimmed);
+    if (foreignWindowsPath && path.posix.isAbsolute(normalizedRoot)) return "<outside-root>";
+    try {
+      if (isPathInside(normalizedRoot, trimmed)) {
+        return relativePosix(normalizedRoot, trimmed);
+      }
+    } catch {
+    }
+    return "<outside-root>";
+  };
+  let redacted = message.replace(
+    /(["'`])([^"'`\r\n]+)\1/g,
+    (quoted, quote, contents) => isAbsolutePath(contents) || isFileSystemUri(contents) ? `${quote}${redact(contents)}${quote}` : quoted
+  );
+  for (const rootVariant of [normalizedRoot, toPosixPath(normalizedRoot)].sort(
+    (a, b) => b.length - a.length
+  )) {
+    if (rootVariant) redacted = redacted.replaceAll(rootVariant, ".");
+  }
+  const chunks = redacted.split(
+    /(\s+(?:is|was|at|from|to|outside|inside|cannot|could|failed|for|and|or)\s+)/gi
+  );
+  return chunks.map(
+    (chunk) => chunk.replace(
+      /(?<![A-Za-z0-9_.-])[A-Za-z]:[\\/](?:[^\\/\r\n'"`)\],;:]+[\\/])*[^\\/\s'"`)\],;:]+|(?<![A-Za-z0-9_.\\-])\\\\(?:[^\\\r\n'"`)\],;:]+\\)+[^\\\s'"`)\],;:]+|(?<![A-Za-z0-9_.:/-])\/\/(?:[^/\r\n'"`)\],;:]+\/)*[^/\s'"`)\],;:]+|(?<![A-Za-z0-9_.:/-])\/(?:[^/\r\n'"`)\],;:]+\/)*[^/\s'"`)\],;:]+/g,
+      redact
+    )
+  ).join("");
+}
+function normalizeStoredPath(value) {
+  const normalized = path.posix.normalize(toPosixPath(value));
+  return normalized.startsWith("./") ? normalized.slice(2) : normalized;
+}
+function sanitizeModuleSpecifier(value) {
+  return isAbsolutePath(value) || isFileSystemUri(value) || hasEmbeddedAbsolutePath(value) ? "<absolute-import>" : value;
+}
+
+// src/ids.ts
+function fileId(filePath) {
+  return `file:${normalizeStoredPath(filePath)}`;
+}
+function symbolId(kind, filePath, name, parent) {
+  const prefix = symbolPrefix(kind);
+  const qualifiedName = parent ? `${parent}.${name}` : name;
+  return `${prefix}:${normalizeStoredPath(filePath)}#${qualifiedName}`;
+}
+function externalId(moduleName, name = "default") {
+  return `external:${sanitizeModuleSpecifier(moduleName)}#${name}`;
+}
+function generatedCompilerUnitId(name) {
+  return `compiler-unit:generated:${normalizeStoredPath(name)}`;
+}
+function routeId(method, route) {
+  return `route:${method.toUpperCase()}:${route || "/"}`;
+}
+function symbolPrefix(kind) {
+  switch (kind) {
+    case "react-component":
+      return "component";
+    case "react-hook":
+      return "hook";
+    case "next-page":
+    case "next-layout":
+    case "next-route-handler":
+    case "next-special-file":
+      return "next";
+    case "nest-module":
+    case "nest-controller":
+    case "nest-provider":
+    case "nest-guard":
+    case "nest-interceptor":
+    case "nest-pipe":
+    case "nest-filter":
+    case "nest-gateway":
+      return "nest";
+    case "type-alias":
+      return "type";
+    default:
+      return kind;
+  }
+}
+
+// src/schemas.ts
+import path3 from "path";
+import { z } from "zod";
+
+// src/utils/stable.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+function compareText(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function safeRecordEntry(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => safeRecordEntry(entry));
+  }
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    const next = {};
+    for (const key of Object.keys(record).sort(compareText)) {
+      const child = record[key];
+      if (child !== void 0) {
+        next[key] = safeRecordEntry(child);
+      }
+    }
+    return next;
+  }
+  return value;
+}
+function stableValue(value) {
+  if (Array.isArray(value)) {
+    return safeRecordEntry(value);
+  }
+  if (value !== null && typeof value === "object") {
+    return safeRecordEntry(value);
+  }
+  return value;
+}
+function stableJson(value, pretty = false) {
+  return `${JSON.stringify(stableValue(value), null, pretty ? 2 : void 0)}
+`;
+}
+
+// src/schemas.ts
+var JsonValueSchema = z.json();
+var LanguageSchema = z.enum(["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"]);
+var FrameworkSchema = z.enum(["typescript", "node", "react", "nextjs", "nestjs"]);
+var FrameworkSelectionSchema = z.union([FrameworkSchema, z.literal("auto")]);
+var ConfigSchema = z.object({
+  version: z.literal(CONFIG_VERSION).default(CONFIG_VERSION),
+  root: z.string().min(1).default("../.."),
+  include: z.array(z.string().min(1)).min(1).default([...DEFAULT_INCLUDE]),
+  exclude: z.array(z.string().min(1)).default([...DEFAULT_EXCLUDE]),
+  tsconfig: z.string().min(1).optional(),
+  frameworks: z.array(FrameworkSelectionSchema).min(1).default(["auto"]),
+  output: z.string().min(1).default(DEFAULT_OUTPUT),
+  includePrivateSymbols: z.boolean().default(false),
+  concurrency: z.number().int().min(1).max(64).optional()
+}).strict().superRefine((config, context) => {
+  if (new Set(config.frameworks).size !== config.frameworks.length) {
+    context.addIssue({
+      code: "custom",
+      path: ["frameworks"],
+      message: "framework selections must be unique"
+    });
+  }
+  if (config.frameworks.includes("auto") && config.frameworks.length > 1) {
+    context.addIssue({
+      code: "custom",
+      path: ["frameworks"],
+      message: "auto cannot be combined with explicit framework selections"
+    });
+  }
+});
+var SourceRangeSchema = z.object({
+  startLine: z.number().int().positive(),
+  startColumn: z.number().int().positive(),
+  endLine: z.number().int().positive(),
+  endColumn: z.number().int().positive()
+}).strict().superRefine((range, context) => {
+  if (range.endLine < range.startLine || range.endLine === range.startLine && range.endColumn < range.startColumn) {
+    context.addIssue({ code: "custom", message: "range end must not precede its start" });
+  }
+});
+var StoredPathSchema = z.string().min(1).refine(
+  (value) => !value.includes("\\") && !value.startsWith("/") && !hasEmbeddedAbsolutePath(value) && !value.split("/").includes(".."),
+  "must be a repository-relative POSIX path"
+).refine((value) => value === normalizeStoredPath(value), "must be normalized");
+var StoredFilePathSchema = StoredPathSchema.refine(
+  (value) => value !== ".",
+  "must identify a file or non-root project path"
+);
+var StoredModuleAliasSchema = z.string().min(1).refine(
+  (value) => !isAbsolutePath(value) && !toPosixPath(value).split("/").includes(".."),
+  "must not contain an absolute or parent-traversing path"
+);
+var ImportSpecifierRecordSchema = z.object({
+  imported: z.string(),
+  local: z.string(),
+  typeOnly: z.boolean().optional()
+}).strict();
+var ImportRecordSchema = z.object({
+  source: z.string().min(1).refine((value) => !isAbsolutePath(value), "must not expose an absolute module path"),
+  specifiers: z.array(ImportSpecifierRecordSchema),
+  resolved: StoredFilePathSchema.optional(),
+  external: z.boolean(),
+  kind: z.enum(["esm", "commonjs"]),
+  line: z.number().int().positive()
+}).strict();
+var ExportRecordSchema = z.object({
+  name: z.string(),
+  local: z.string().optional(),
+  source: z.string().refine((value) => !isAbsolutePath(value), "must not expose an absolute module path").optional(),
+  default: z.boolean(),
+  typeOnly: z.boolean().optional(),
+  line: z.number().int().positive()
+}).strict();
+var ExternalOperationKindSchema = z.enum(["filesystem", "http", "database", "queue"]);
+var ExternalOperationSchema = z.object({
+  kind: ExternalOperationKindSchema,
+  api: z.string().min(1),
+  line: z.number().int().positive()
+}).strict();
+var SyntaxSummarySchema = z.object({
+  parser: z.string().min(1),
+  factCount: z.number().int().nonnegative(),
+  hadErrors: z.boolean(),
+  fallbackFrom: z.string().min(1).optional()
+}).strict();
+var FileRecordSchema = z.object({
+  schemaVersion: z.literal(SCHEMA_VERSION),
+  id: z.string().min(1),
+  compilerUnit: z.string().min(1),
+  path: StoredFilePathSchema,
+  language: LanguageSchema,
+  frameworks: z.array(FrameworkSchema),
+  hash: z.string().regex(/^[a-f0-9]{64}$/),
+  lines: z.number().int().nonnegative(),
+  imports: z.array(ImportRecordSchema),
+  exports: z.array(ExportRecordSchema),
+  symbolIds: z.array(z.string().min(1)),
+  env: z.array(z.string()),
+  operations: z.array(ExternalOperationSchema),
+  syntax: SyntaxSummarySchema
+}).strict();
+var CompilerUnitRecordSchema = z.object({
+  id: z.string().min(1),
+  kind: z.enum(["configured", "fallback"]),
+  root: StoredPathSchema,
+  config: StoredFilePathSchema.optional(),
+  references: z.array(StoredFilePathSchema),
+  extends: z.array(StoredFilePathSchema),
+  pathAliases: z.record(StoredModuleAliasSchema, z.array(StoredPathSchema))
+}).strict();
+var SymbolKindSchema = z.enum([
+  "function",
+  "class",
+  "method",
+  "interface",
+  "type-alias",
+  "variable",
+  "react-component",
+  "react-hook",
+  "react-context",
+  "next-page",
+  "next-layout",
+  "next-route-handler",
+  "next-special-file",
+  "nest-module",
+  "nest-controller",
+  "nest-provider",
+  "nest-guard",
+  "nest-interceptor",
+  "nest-pipe",
+  "nest-filter",
+  "nest-gateway",
+  "dto",
+  "route"
+]);
+var SymbolRecordSchema = z.object({
+  schemaVersion: z.literal(SCHEMA_VERSION),
+  id: z.string().min(1),
+  name: z.string(),
+  kind: SymbolKindSchema,
+  file: StoredFilePathSchema,
+  range: SourceRangeSchema,
+  exported: z.boolean(),
+  defaultExport: z.boolean().optional(),
+  signature: z.string().optional(),
+  documentation: z.string().optional(),
+  facts: z.record(z.string(), JsonValueSchema),
+  sourceHash: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var RelationTypeSchema = z.enum([
+  "imports",
+  "exports",
+  "reexports",
+  "calls",
+  "instantiates",
+  "renders",
+  "uses-hook",
+  "reads-state",
+  "depends-on",
+  "used-by",
+  "contains",
+  "references",
+  "injects",
+  "handles-route",
+  "consumes-dto",
+  "belongs-to-module",
+  "uses-layout"
+]);
+var RelationEvidenceClassificationSchema = z.enum([
+  "exact",
+  "framework-derived",
+  "heuristic",
+  "derived"
+]);
+var RelationOriginSchema = z.object({
+  file: StoredFilePathSchema,
+  line: z.number().int().positive(),
+  range: SourceRangeSchema,
+  explanation: z.string().min(1),
+  classification: RelationEvidenceClassificationSchema,
+  analyzer: z.string().min(1)
+}).strict();
+var RelationRecordSchema = z.object({
+  schemaVersion: z.literal(SCHEMA_VERSION),
+  from: z.string().min(1),
+  type: RelationTypeSchema,
+  to: z.string().min(1),
+  confidence: z.number().min(0).max(1),
+  origin: RelationOriginSchema
+}).strict();
+var DiagnosticSeveritySchema = z.enum(["info", "warning", "error"]);
+var DiagnosticCodeSchema = z.enum([
+  "parse-error",
+  "unresolved-import",
+  "invalid-config",
+  "unsupported-file",
+  "analysis-error",
+  "parser-fallback",
+  "compiler-config"
+]);
+var DiagnosticRecordSchema = z.object({
+  schemaVersion: z.literal(SCHEMA_VERSION),
+  code: DiagnosticCodeSchema,
+  severity: DiagnosticSeveritySchema,
+  message: z.string().min(1),
+  file: StoredFilePathSchema.optional(),
+  line: z.number().int().positive().optional(),
+  column: z.number().int().positive().optional()
+}).strict();
+var WorkspacePackageSchema = z.object({
+  name: z.string(),
+  path: StoredFilePathSchema,
+  entryPoints: z.array(StoredFilePathSchema)
+}).strict();
+var MapCountsSchema = z.object({
+  files: z.number().int().nonnegative(),
+  symbols: z.number().int().nonnegative(),
+  relations: z.number().int().nonnegative(),
+  diagnostics: z.number().int().nonnegative()
+}).strict();
+var ProjectRecordSchema = z.object({
+  schemaVersion: z.literal(SCHEMA_VERSION),
+  name: z.string(),
+  packageManager: z.string().optional(),
+  frameworks: z.array(FrameworkSchema),
+  compilerUnits: z.array(CompilerUnitRecordSchema),
+  tsconfig: StoredFilePathSchema.optional(),
+  pathAliases: z.record(StoredModuleAliasSchema, z.array(StoredPathSchema)),
+  entryPoints: z.array(StoredFilePathSchema),
+  workspaces: z.array(WorkspacePackageSchema),
+  counts: MapCountsSchema
+}).strict();
+var ManifestSourceFileSchema = z.object({
+  path: StoredFilePathSchema,
+  hash: z.string().regex(/^[a-f0-9]{64}$/),
+  compilerUnit: z.string().min(1),
+  lines: z.number().int().nonnegative()
+}).strict();
+var SemanticFileInputRecordSchema = z.object({
+  path: StoredPathSchema,
+  kind: z.literal("file"),
+  hash: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var SemanticResolutionProbeRecordSchema = z.object({
+  path: StoredPathSchema,
+  kind: z.literal("resolution-probe"),
+  scope: z.enum(["project", "toolchain"]),
+  targetKind: z.enum(["file", "directory", "readable-file"]),
+  exists: z.boolean()
+}).strict();
+var SemanticDirectoryListingRecordSchema = z.object({
+  path: StoredPathSchema,
+  kind: z.literal("directory-listing"),
+  scope: z.enum(["project", "toolchain"]),
+  hash: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var SemanticSymlinkRecordSchema = z.object({
+  path: StoredPathSchema,
+  kind: z.literal("symlink"),
+  scope: z.enum(["project", "toolchain"]),
+  target: StoredPathSchema
+}).strict();
+var SemanticToolchainFileRecordSchema = z.object({
+  path: StoredPathSchema,
+  kind: z.literal("toolchain-file"),
+  hash: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var SemanticInputRecordSchema = z.discriminatedUnion("kind", [
+  SemanticFileInputRecordSchema,
+  SemanticResolutionProbeRecordSchema,
+  SemanticDirectoryListingRecordSchema,
+  SemanticSymlinkRecordSchema,
+  SemanticToolchainFileRecordSchema
+]);
+var ArtifactIntegrityRecordSchema = z.object({
+  path: z.enum(MAP_COMPANION_ARTIFACTS),
+  hash: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var ProducerRecordSchema = z.object({
+  id: z.string().min(1),
+  kind: z.enum(["built-in", "custom"]),
+  fingerprint: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var VersionedToolSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1)
+}).strict();
+var ManifestRecordSchema = z.object({
+  schemaVersion: z.literal(SCHEMA_VERSION),
+  analyzerVersion: z.string().min(1),
+  producer: ProducerRecordSchema,
+  semanticResolver: VersionedToolSchema,
+  syntaxParser: VersionedToolSchema,
+  analyzers: z.array(VersionedToolSchema),
+  configHash: z.string().regex(/^[a-f0-9]{64}$/),
+  sourceFiles: z.array(ManifestSourceFileSchema),
+  semanticInputs: z.array(SemanticInputRecordSchema),
+  artifacts: z.array(ArtifactIntegrityRecordSchema),
+  integrityHash: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var CodeMapShapeSchema = z.object({
+  manifest: ManifestRecordSchema,
+  project: ProjectRecordSchema,
+  files: z.array(FileRecordSchema),
+  symbols: z.array(SymbolRecordSchema),
+  relations: z.array(RelationRecordSchema),
+  diagnostics: z.array(DiagnosticRecordSchema)
+}).strict();
+var CodeMapSchema = CodeMapShapeSchema.superRefine((map, context) => {
+  const fileByPath = new Map(map.files.map((file) => [file.path, file]));
+  const fileIds = /* @__PURE__ */ new Set();
+  const filePaths = /* @__PURE__ */ new Set();
+  const compilerUnitsById = new Map(map.project.compilerUnits.map((unit) => [unit.id, unit]));
+  const compilerUnitIds = /* @__PURE__ */ new Set();
+  let fallbackCount = 0;
+  for (const [index, file] of map.files.entries()) {
+    addDuplicateIssue(context, fileIds, file.id, ["files", index, "id"]);
+    addDuplicateIssue(context, filePaths, file.path, ["files", index, "path"]);
+    if (file.id !== `file:${file.path}`) {
+      context.addIssue({
+        code: "custom",
+        path: ["files", index, "id"],
+        message: "file ID must be derived from its path"
+      });
+    }
+  }
+  for (const [index, unit] of map.project.compilerUnits.entries()) {
+    addDuplicateIssue(context, compilerUnitIds, unit.id, ["project", "compilerUnits", index, "id"]);
+    if (unit.kind === "configured" && !unit.config) {
+      context.addIssue({
+        code: "custom",
+        path: ["project", "compilerUnits", index, "config"],
+        message: "configured compiler units require config"
+      });
+    }
+    if (unit.kind === "fallback" && unit.config) {
+      context.addIssue({
+        code: "custom",
+        path: ["project", "compilerUnits", index, "config"],
+        message: "fallback compiler units must not have config"
+      });
+    }
+    if (unit.kind === "fallback") {
+      fallbackCount += 1;
+      if (unit.id !== "compiler-unit:generated:fallback" || unit.root !== "." || unit.references.length > 0 || unit.extends.length > 0 || Object.keys(unit.pathAliases).length > 0) {
+        context.addIssue({
+          code: "custom",
+          path: ["project", "compilerUnits", index],
+          message: "fallback compiler unit must use the canonical generated identity and shape"
+        });
+      }
+    }
+    if (unit.kind === "configured" && unit.config) {
+      if (unit.id !== `compiler-unit:configured:${unit.config}`) {
+        context.addIssue({
+          code: "custom",
+          path: ["project", "compilerUnits", index, "id"],
+          message: "configured compiler-unit ID must be derived from its config path"
+        });
+      }
+      if (unit.root !== normalizeStoredPath(path3.posix.dirname(unit.config))) {
+        context.addIssue({
+          code: "custom",
+          path: ["project", "compilerUnits", index, "root"],
+          message: "configured compiler-unit root must match its config directory"
+        });
+      }
+    }
+  }
+  if (fallbackCount !== 1) {
+    context.addIssue({
+      code: "custom",
+      path: ["project", "compilerUnits"],
+      message: "exactly one fallback compiler unit is required"
+    });
+  }
+  const configuredPaths = new Set(
+    map.project.compilerUnits.flatMap(
+      (unit) => unit.kind === "configured" && unit.config ? [unit.config] : []
+    )
+  );
+  if (map.project.tsconfig && !configuredPaths.has(map.project.tsconfig)) {
+    context.addIssue({
+      code: "custom",
+      path: ["project", "tsconfig"],
+      message: "project tsconfig must resolve to a configured compiler unit"
+    });
+  }
+  const compatibilityUnit = map.project.tsconfig ? map.project.compilerUnits.find((unit) => unit.config === map.project.tsconfig) : map.project.compilerUnits.filter((unit) => unit.kind === "configured").sort((left, right) => compareText(left.id, right.id))[0];
+  if (stableJson(map.project.pathAliases) !== stableJson(compatibilityUnit?.pathAliases ?? {})) {
+    context.addIssue({
+      code: "custom",
+      path: ["project", "pathAliases"],
+      message: "project path aliases must match the compatibility compiler unit"
+    });
+  }
+  for (const [index, unit] of map.project.compilerUnits.entries()) {
+    for (const reference of unit.references) {
+      if (!configuredPaths.has(reference)) {
+        context.addIssue({
+          code: "custom",
+          path: ["project", "compilerUnits", index, "references"],
+          message: "compiler-unit reference must resolve to a configured unit"
+        });
+      }
+    }
+  }
+  const symbolById = /* @__PURE__ */ new Map();
+  for (const [index, symbol] of map.symbols.entries()) {
+    if (symbolById.has(symbol.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["symbols", index, "id"],
+        message: `duplicate symbol ID ${symbol.id}`
+      });
+    }
+    symbolById.set(symbol.id, symbol);
+    const owner = fileByPath.get(symbol.file);
+    if (!owner) {
+      context.addIssue({
+        code: "custom",
+        path: ["symbols", index, "file"],
+        message: "symbol references a missing file"
+      });
+    } else if (owner.hash !== symbol.sourceHash) {
+      context.addIssue({
+        code: "custom",
+        path: ["symbols", index, "sourceHash"],
+        message: "symbol source hash does not match its file"
+      });
+    } else if (!rangeFitsFile(symbol.range, owner)) {
+      context.addIssue({
+        code: "custom",
+        path: ["symbols", index, "range"],
+        message: "symbol range must fit within its source file"
+      });
+    }
+  }
+  const importRelationKeys = new Set(
+    map.relations.filter((relation2) => relation2.type === "imports").map(
+      (relation2) => `${relation2.from}\0${relation2.to}\0${relation2.origin.file}\0${relation2.origin.line}`
+    )
+  );
+  const expectedImportRelationKeys = /* @__PURE__ */ new Set();
+  for (const [fileIndex, file] of map.files.entries()) {
+    const unit = compilerUnitsById.get(file.compilerUnit);
+    if (!unit) {
+      context.addIssue({
+        code: "custom",
+        path: ["files", fileIndex, "compilerUnit"],
+        message: "file compiler unit must resolve to exactly one compiler unit"
+      });
+    }
+    const expected = map.symbols.filter((symbol) => symbol.file === file.path).map((symbol) => symbol.id).sort();
+    const actual = [...file.symbolIds].sort();
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+      context.addIssue({
+        code: "custom",
+        path: ["files", fileIndex, "symbolIds"],
+        message: "file symbol IDs must exactly match symbols owned by the file"
+      });
+    }
+    for (const [importIndex, importRecord] of file.imports.entries()) {
+      if (importRecord.line > file.lines) {
+        context.addIssue({
+          code: "custom",
+          path: ["files", fileIndex, "imports", importIndex, "line"],
+          message: "import line must fit within its source file"
+        });
+      }
+      if (importRecord.external && importRecord.resolved) {
+        context.addIssue({
+          code: "custom",
+          path: ["files", fileIndex, "imports", importIndex],
+          message: "external imports must not name an internal resolved path"
+        });
+      }
+      if (importRecord.resolved && !fileByPath.has(importRecord.resolved)) {
+        context.addIssue({
+          code: "custom",
+          path: ["files", fileIndex, "imports", importIndex, "resolved"],
+          message: "resolved import must reference a persisted file"
+        });
+      }
+      const target = importRecord.resolved ? `file:${importRecord.resolved}` : `external:${importRecord.source}#default`;
+      const key = `${file.id}\0${target}\0${file.path}\0${importRecord.line}`;
+      expectedImportRelationKeys.add(key);
+      if (!importRelationKeys.has(key)) {
+        context.addIssue({
+          code: "custom",
+          path: ["files", fileIndex, "imports", importIndex],
+          message: "import record must have matching relation evidence"
+        });
+      }
+    }
+    for (const [exportIndex, exportRecord] of file.exports.entries()) {
+      if (exportRecord.line > file.lines) {
+        context.addIssue({
+          code: "custom",
+          path: ["files", fileIndex, "exports", exportIndex, "line"],
+          message: "export line must fit within its source file"
+        });
+      }
+    }
+    for (const [operationIndex, operation] of file.operations.entries()) {
+      if (operation.line > file.lines) {
+        context.addIssue({
+          code: "custom",
+          path: ["files", fileIndex, "operations", operationIndex, "line"],
+          message: "operation line must fit within its source file"
+        });
+      }
+    }
+  }
+  const manifestPaths = /* @__PURE__ */ new Set();
+  for (const [index, source] of map.manifest.sourceFiles.entries()) {
+    addDuplicateIssue(context, manifestPaths, source.path, [
+      "manifest",
+      "sourceFiles",
+      index,
+      "path"
+    ]);
+    const file = fileByPath.get(source.path);
+    if (!file || file.hash !== source.hash) {
+      context.addIssue({
+        code: "custom",
+        path: ["manifest", "sourceFiles", index],
+        message: "manifest source must match a persisted file and hash"
+      });
+    } else if (file.compilerUnit !== source.compilerUnit) {
+      context.addIssue({
+        code: "custom",
+        path: ["manifest", "sourceFiles", index, "compilerUnit"],
+        message: "manifest source ownership must match the persisted file compiler unit"
+      });
+    } else if (file.lines !== source.lines) {
+      context.addIssue({
+        code: "custom",
+        path: ["manifest", "sourceFiles", index, "lines"],
+        message: "manifest source line count must match the persisted file"
+      });
+    }
+  }
+  if (manifestPaths.size !== fileByPath.size) {
+    context.addIssue({
+      code: "custom",
+      path: ["manifest", "sourceFiles"],
+      message: "manifest sources must exactly cover persisted files"
+    });
+  }
+  const semanticInputIdentities = /* @__PURE__ */ new Set();
+  for (const [index, input] of map.manifest.semanticInputs.entries()) {
+    addDuplicateIssue(context, semanticInputIdentities, semanticInputIdentity(input), [
+      "manifest",
+      "semanticInputs",
+      index
+    ]);
+  }
+  const artifactPaths = /* @__PURE__ */ new Set();
+  for (const [index, artifact] of map.manifest.artifacts.entries()) {
+    addDuplicateIssue(context, artifactPaths, artifact.path, [
+      "manifest",
+      "artifacts",
+      index,
+      "path"
+    ]);
+  }
+  const expectedArtifacts = [...MAP_COMPANION_ARTIFACTS].sort();
+  if (JSON.stringify([...artifactPaths].sort()) !== JSON.stringify(expectedArtifacts)) {
+    context.addIssue({
+      code: "custom",
+      path: ["manifest", "artifacts"],
+      message: "manifest artifact hashes must exactly cover every companion artifact"
+    });
+  }
+  const counts = {
+    files: map.files.length,
+    symbols: map.symbols.length,
+    relations: map.relations.length,
+    diagnostics: map.diagnostics.length
+  };
+  for (const key of Object.keys(counts)) {
+    if (map.project.counts[key] !== counts[key]) {
+      context.addIssue({
+        code: "custom",
+        path: ["project", "counts", key],
+        message: `${key} count does not match persisted records`
+      });
+    }
+  }
+  const validEndpoints = /* @__PURE__ */ new Set([...fileIds, ...symbolById.keys()]);
+  const relationIdentities = /* @__PURE__ */ new Set();
+  for (const [index, relation2] of map.relations.entries()) {
+    addDuplicateIssue(context, relationIdentities, relationIdentity(relation2), [
+      "relations",
+      index
+    ]);
+    if (relation2.type === "imports") {
+      const key = `${relation2.from}\0${relation2.to}\0${relation2.origin.file}\0${relation2.origin.line}`;
+      if (!expectedImportRelationKeys.has(key)) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", index],
+          message: "imports relation must have a matching file import record"
+        });
+      }
+    }
+    for (const endpoint of [relation2.from, relation2.to]) {
+      if (!validEndpoints.has(endpoint) && !endpoint.startsWith("external:") && !endpoint.startsWith("route:")) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", index],
+          message: `relation references missing endpoint ${endpoint}`
+        });
+      }
+    }
+    const originFile = fileByPath.get(relation2.origin.file);
+    if (!originFile) {
+      context.addIssue({
+        code: "custom",
+        path: ["relations", index, "origin", "file"],
+        message: "relation evidence references a missing file"
+      });
+    } else {
+      if (relation2.origin.line !== relation2.origin.range.startLine) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", index, "origin", "line"],
+          message: "relation origin line must match the start of its evidence range"
+        });
+      }
+      if (!rangeFitsFile(relation2.origin.range, originFile)) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", index, "origin", "range"],
+          message: "relation evidence range must fit within its source file"
+        });
+      }
+      if (relation2.type === "contains" || relation2.type === "exports") {
+        const fromFile = endpointSourceFile(relation2.from, fileByPath, symbolById);
+        const toFile = endpointSourceFile(relation2.to, fileByPath, symbolById);
+        if (fromFile !== relation2.origin.file || relation2.type === "exports" && toFile !== relation2.origin.file) {
+          context.addIssue({
+            code: "custom",
+            path: ["relations", index],
+            message: relation2.type === "exports" ? "exports endpoints and evidence must belong to the same file" : "contains evidence must belong to its source endpoint file"
+          });
+        }
+        const fromIsFile = relation2.from.startsWith("file:");
+        const toSymbol = symbolById.get(relation2.to);
+        const fromSymbol = symbolById.get(relation2.from);
+        if (relation2.type === "contains" && fromIsFile) {
+          if (!toSymbol || toSymbol.file !== relation2.origin.file || !rangesEqual(toSymbol.range, relation2.origin.range)) {
+            context.addIssue({
+              code: "custom",
+              path: ["relations", index],
+              message: "file containment evidence must exactly identify a symbol owned by the file"
+            });
+          }
+        } else if (relation2.type === "contains" && fromSymbol) {
+          if (!toSymbol || !rangeContains(fromSymbol.range, relation2.origin.range)) {
+            context.addIssue({
+              code: "custom",
+              path: ["relations", index, "origin", "range"],
+              message: "symbol containment must target a symbol and its evidence must fall within the source symbol"
+            });
+          }
+        }
+        if (relation2.type === "exports" && (!fromIsFile || !toSymbol || !toSymbol.exported || !rangesEqual(toSymbol.range, relation2.origin.range))) {
+          context.addIssue({
+            code: "custom",
+            path: ["relations", index],
+            message: "exports evidence must exactly identify an exported symbol owned by the file"
+          });
+        }
+      }
+    }
+  }
+  for (const [index, diagnostic] of map.diagnostics.entries()) {
+    const file = diagnostic.file ? fileByPath.get(diagnostic.file) : void 0;
+    if (file && diagnostic.line && diagnostic.line > file.lines) {
+      context.addIssue({
+        code: "custom",
+        path: ["diagnostics", index, "line"],
+        message: "diagnostic line must fit within its source file"
+      });
+    }
+  }
+});
+function addDuplicateIssue(context, seen, value, path10) {
+  if (seen.has(value)) {
+    context.addIssue({ code: "custom", path: path10, message: `duplicate value ${value}` });
+  }
+  seen.add(value);
+}
+function relationIdentity(relation2) {
+  const range = relation2.origin.range;
+  return [
+    relation2.from,
+    relation2.type,
+    relation2.to,
+    relation2.origin.file,
+    range.startLine,
+    range.startColumn,
+    range.endLine,
+    range.endColumn
+  ].join("\0");
+}
+function semanticInputIdentity(input) {
+  return input.kind === "resolution-probe" ? `${input.scope}\0${input.path}\0${input.kind}\0${input.targetKind}` : input.kind === "directory-listing" || input.kind === "symlink" ? `${input.scope}\0${input.path}\0${input.kind}` : `${input.path}\0${input.kind}`;
+}
+function rangeFitsFile(range, file) {
+  return range.startLine <= file.lines && range.endLine <= file.lines;
+}
+function rangesEqual(left, right) {
+  return left.startLine === right.startLine && left.startColumn === right.startColumn && left.endLine === right.endLine && left.endColumn === right.endColumn;
+}
+function rangeContains(outer, inner) {
+  const startsAfter = inner.startLine > outer.startLine || inner.startLine === outer.startLine && inner.startColumn >= outer.startColumn;
+  const endsBefore = inner.endLine < outer.endLine || inner.endLine === outer.endLine && inner.endColumn <= outer.endColumn;
+  return startsAfter && endsBefore;
+}
+function endpointSourceFile(endpoint, files, symbols) {
+  if (endpoint.startsWith("file:")) return files.get(endpoint.slice("file:".length))?.path;
+  return symbols.get(endpoint)?.file;
+}
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashText(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+// src/analyzers/core.ts
+import { isBuiltin } from "module";
+import path4 from "path";
+import ts2 from "typescript";
+
+// src/analyzers/helpers.ts
+import ts from "typescript";
+function nodeRange(sourceFile, node) {
+  const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile, false));
+  const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+  return {
+    startLine: start.line + 1,
+    startColumn: start.character + 1,
+    endLine: end.line + 1,
+    endColumn: end.character + 1
+  };
+}
+function nodeLine(sourceFile, node) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile, false)).line + 1;
+}
+function hasModifier(node, kind) {
+  return Boolean(
+    ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((item) => item.kind === kind)
+  );
+}
+function hasExportModifier(node) {
+  return hasModifier(node, ts.SyntaxKind.ExportKeyword);
+}
+function hasDefaultModifier(node) {
+  return hasModifier(node, ts.SyntaxKind.DefaultKeyword);
+}
+function getDeclarationName(node, fallback = "default") {
+  const name = node.name;
+  if (name && ts.isIdentifier(name)) return name.text;
+  if (name && (ts.isStringLiteral(name) || ts.isNumericLiteral(name))) return name.text;
+  return fallback;
+}
+function getTopLevelDefaultExportDeclaration(sourceFile) {
+  for (const statement of sourceFile.statements) {
+    if (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)) {
+      const defaultName = statement.expression.text;
+      const declaration = topLevelDeclarations(sourceFile).find(
+        (item) => getDeclarationName(item, "") === defaultName
+      );
+      if (declaration) return declaration;
+      continue;
+    }
+    if (ts.isFunctionDeclaration(statement) && hasDefaultModifier(statement)) return statement;
+    if (ts.isClassDeclaration(statement) && hasDefaultModifier(statement)) return statement;
+    if (ts.isInterfaceDeclaration(statement) && hasDefaultModifier(statement)) return statement;
+    if (ts.isTypeAliasDeclaration(statement) && hasDefaultModifier(statement)) return statement;
+    if (ts.isEnumDeclaration(statement) && hasDefaultModifier(statement)) return statement;
+    if (ts.isVariableStatement(statement) && hasDefaultModifier(statement)) {
+      const declaration = statement.declarationList.declarations.find(
+        (item) => ts.isIdentifier(item.name)
+      );
+      return declaration;
+    }
+  }
+  return void 0;
+}
+function hasAnyTopLevelExport(sourceFile) {
+  return sourceFile.statements.some(
+    (statement) => ts.isExportAssignment(statement) || hasExportModifier(statement)
+  );
+}
+function topLevelDeclarations(sourceFile) {
+  return sourceFile.statements.flatMap((statement) => {
+    if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) || ts.isEnumDeclaration(statement)) {
+      return [statement];
+    }
+    if (ts.isVariableStatement(statement)) return [...statement.declarationList.declarations];
+    return [];
+  });
+}
+function getSignature(context, node) {
+  const type = context.checker.getTypeAtLocation(node);
+  const signatures = type.getCallSignatures();
+  if (signatures.length > 0) {
+    return [
+      ...new Set(
+        signatures.map(
+          (signature) => context.checker.signatureToString(
+            signature,
+            node,
+            ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
+          )
+        )
+      )
+    ].map(redactStringLiterals).join(" | ");
+  }
+  if (ts.isClassDeclaration(node)) {
+    return compactText(node.getText(context.sourceFile).split(/[\r\n{]/, 1)[0] ?? "");
+  }
+  if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+    return compactText(redactStringLiterals(node.getText(context.sourceFile)));
+  }
+  if (ts.isVariableDeclaration(node) && node.type) {
+    return `${getDeclarationName(node)}: ${compactText(node.type.getText(context.sourceFile))}`;
+  }
+  return void 0;
+}
+function redactStringLiterals(value) {
+  return value.replace(/(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/g, '"<literal>"');
+}
+function makeSymbol(context, node, kind, options = {}) {
+  const name = options.name ?? (ts.isSourceFile(node) ? "default" : getDeclarationName(node));
+  const documentation = options.documentation;
+  const signature = options.signature ?? (ts.isSourceFile(node) ? void 0 : getSignature(context, node));
+  const safeSignature = signature ? redactAbsolutePathsInText(signature, context.root) : void 0;
+  const safeDocumentation = documentation ? redactAbsolutePathsInText(documentation, context.root) : void 0;
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: symbolId(kind, context.relativePath, name, options.parent),
+    name,
+    kind,
+    file: context.relativePath,
+    range: nodeRange(context.sourceFile, node),
+    exported: options.exported ?? (!ts.isSourceFile(node) && hasExportModifier(node)),
+    ...options.defaultExport ?? (!ts.isSourceFile(node) && hasDefaultModifier(node)) ? { defaultExport: true } : {},
+    ...safeSignature ? { signature: compactText(safeSignature) } : {},
+    ...safeDocumentation ? { documentation: compactText(safeDocumentation) } : {},
+    facts: options.facts ?? {},
+    sourceHash: context.sourceHash
+  };
+}
+function compactText(value, maxLength = 500) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  return compact.length > maxLength ? `${compact.slice(0, maxLength - 1)}\u2026` : compact;
+}
+function visit(node, callback) {
+  callback(node);
+  node.forEachChild((child) => visit(child, callback));
+}
+function decoratorsOf(node) {
+  return ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : [];
+}
+function propertyNameText(name) {
+  if (!name) return void 0;
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+    return name.text;
+  return void 0;
+}
+
+// src/analyzers/core.ts
+var CoreAnalyzer = class {
+  name = "typescript-node";
+  version = ANALYZER_VERSION;
+  supports() {
+    return true;
+  }
+  analyze(context) {
+    const symbols = [];
+    const relations = [];
+    const seenSymbols = /* @__PURE__ */ new Map();
+    for (const statement of context.sourceFile.statements) {
+      extractTopLevelSymbol(context, statement, seenSymbols, relations);
+    }
+    symbols.push(...seenSymbols.values());
+    const declarationIds = declarationIdMap(context, symbols);
+    collectBehaviorRelations(context, declarationIds, relations);
+    return {
+      symbols: symbols.sort((a, b) => compareText(a.id, b.id)),
+      relations,
+      frameworks: ["typescript", "node"]
+    };
+  }
+};
+function extractTopLevelSymbol(context, statement, output, relations) {
+  if (ts2.isFunctionDeclaration(statement)) {
+    const name = statement.name?.text ?? "default";
+    const record = makeSymbol(context, statement, "function", {
+      name,
+      exported: isNameExported(context, name, statement),
+      facts: { async: hasModifier(statement, ts2.SyntaxKind.AsyncKeyword) }
+    });
+    keepBestDeclaration(output, record, Boolean(statement.body));
+    return;
+  }
+  if (ts2.isClassDeclaration(statement)) {
+    const className = statement.name?.text ?? "default";
+    const classRecord = makeSymbol(context, statement, "class", {
+      name: className,
+      exported: isNameExported(context, className, statement)
+    });
+    keepBestDeclaration(output, classRecord, true);
+    for (const member of statement.members) {
+      if (!ts2.isMethodDeclaration(member) && !ts2.isConstructorDeclaration(member)) continue;
+      if (hasModifier(member, ts2.SyntaxKind.PrivateKeyword) && !isPrivateEnabled(context)) {
+        continue;
+      }
+      const name = ts2.isConstructorDeclaration(member) ? "constructor" : propertyNameText(member.name) ?? "anonymous";
+      const method = makeSymbol(context, member, "method", {
+        name,
+        parent: className,
+        exported: classRecord.exported,
+        facts: {
+          async: ts2.isMethodDeclaration(member) ? hasModifier(member, ts2.SyntaxKind.AsyncKeyword) : false
+        }
+      });
+      keepBestDeclaration(output, method, Boolean(member.body));
+      relations.push(
+        relation(classRecord.id, "contains", method.id, context, member, 1, "class member")
+      );
+    }
+    return;
+  }
+  if (ts2.isInterfaceDeclaration(statement)) {
+    keepBestDeclaration(
+      output,
+      makeSymbol(context, statement, "interface", {
+        exported: isNameExported(context, statement.name.text, statement)
+      }),
+      true
+    );
+    return;
+  }
+  if (ts2.isTypeAliasDeclaration(statement)) {
+    keepBestDeclaration(
+      output,
+      makeSymbol(context, statement, "type-alias", {
+        exported: isNameExported(context, statement.name.text, statement)
+      }),
+      true
+    );
+    return;
+  }
+  if (ts2.isVariableStatement(statement)) {
+    const defaultExport = hasDefaultModifier(statement);
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts2.isIdentifier(declaration.name)) continue;
+      const functionLike = declaration.initializer !== void 0 && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer));
+      const record = makeSymbol(context, declaration, functionLike ? "function" : "variable", {
+        exported: isNameExported(context, declaration.name.text, statement),
+        defaultExport,
+        facts: functionLike ? { async: hasModifier(declaration.initializer, ts2.SyntaxKind.AsyncKeyword) } : {}
+      });
+      keepBestDeclaration(output, record, true);
+    }
+  }
+}
+function isNameExported(context, name, node) {
+  if (hasExportModifier(node) || hasDefaultModifier(node)) return true;
+  return context.file.exports.some(
+    (entry) => !entry.source && (entry.local === name || !entry.local && entry.name === name)
+  );
+}
+function isPrivateEnabled(context) {
+  return context.includePrivateSymbols;
+}
+function keepBestDeclaration(output, record, hasImplementation) {
+  const existing = output.get(record.id);
+  if (!existing || hasImplementation || !existing.signature) output.set(record.id, record);
+}
+function declarationIdMap(context, symbols) {
+  const byKey = new Map(symbols.map((symbol) => [`${symbol.kind}:${symbol.name}`, symbol.id]));
+  const result2 = /* @__PURE__ */ new Map();
+  for (const statement of context.sourceFile.statements) {
+    if (ts2.isFunctionDeclaration(statement)) {
+      const name = statement.name?.text ?? "default";
+      const id = byKey.get(`function:${name}`);
+      if (id) result2.set(statement, id);
+    } else if (ts2.isClassDeclaration(statement)) {
+      const name = statement.name?.text ?? "default";
+      const id = byKey.get(`class:${name}`);
+      if (id) result2.set(statement, id);
+      for (const member of statement.members) {
+        if (!ts2.isMethodDeclaration(member) && !ts2.isConstructorDeclaration(member)) continue;
+        const memberName = ts2.isConstructorDeclaration(member) ? "constructor" : propertyNameText(member.name) ?? "anonymous";
+        const memberId = symbolId("method", context.relativePath, memberName, name);
+        result2.set(member, memberId);
+      }
+    } else if (ts2.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts2.isIdentifier(declaration.name)) continue;
+        const kind = declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer)) ? "function" : "variable";
+        const id = byKey.get(`${kind}:${declaration.name.text}`);
+        if (id) result2.set(declaration, id);
+      }
+    } else if (ts2.isInterfaceDeclaration(statement) || ts2.isTypeAliasDeclaration(statement)) {
+      const kind = ts2.isInterfaceDeclaration(statement) ? "interface" : "type-alias";
+      const id = byKey.get(`${kind}:${statement.name.text}`);
+      if (id) result2.set(statement, id);
+    }
+  }
+  return result2;
+}
+function collectBehaviorRelations(context, declarationIds, output) {
+  let currentOwner = fileId(context.relativePath);
+  const walk = (node) => {
+    const previousOwner = currentOwner;
+    if (ts2.isFunctionDeclaration(node) || ts2.isMethodDeclaration(node) || ts2.isConstructorDeclaration(node)) {
+      currentOwner = declarationIds.get(node) ?? currentOwner;
+    } else if ((ts2.isArrowFunction(node) || ts2.isFunctionExpression(node)) && ts2.isVariableDeclaration(node.parent)) {
+      currentOwner = declarationIds.get(node.parent) ?? currentOwner;
+    } else if (ts2.isClassDeclaration(node)) {
+      currentOwner = declarationIds.get(node) ?? currentOwner;
+    }
+    if (ts2.isCallExpression(node) && !isRequireCall(node)) {
+      const target = resolveExpressionTarget(context, node.expression);
+      if (target && target.id !== currentOwner) {
+        output.push(
+          relation(
+            currentOwner,
+            "calls",
+            target.id,
+            context,
+            node,
+            target.exact ? 1 : 0.35,
+            target.exact ? "TypeScript symbol resolution" : "unresolved call syntax"
+          )
+        );
+      }
+    } else if (ts2.isNewExpression(node)) {
+      const target = resolveExpressionTarget(context, node.expression);
+      if (target && target.id !== currentOwner) {
+        output.push(
+          relation(
+            currentOwner,
+            "instantiates",
+            target.id,
+            context,
+            node,
+            target.exact ? 1 : 0.35,
+            target.exact ? "TypeScript constructor resolution" : "unresolved constructor syntax"
+          )
+        );
+      }
+    }
+    if (ts2.isIdentifier(node) && isReferenceIdentifier(node)) {
+      const target = resolveExpressionTarget(context, node, false);
+      if (target?.exact && target.id !== currentOwner && !target.id.startsWith("external:")) {
+        output.push(
+          relation(
+            currentOwner,
+            "references",
+            target.id,
+            context,
+            node,
+            1,
+            "TypeScript symbol reference"
+          )
+        );
+      }
+    }
+    node.forEachChild(walk);
+    currentOwner = previousOwner;
+  };
+  walk(context.sourceFile);
+  for (const statement of context.sourceFile.statements) {
+    if (!ts2.isClassDeclaration(statement)) continue;
+    const from = declarationIds.get(statement);
+    if (!from) continue;
+    for (const clause of statement.heritageClauses ?? []) {
+      for (const type of clause.types) {
+        const target = resolveExpressionTarget(context, type.expression);
+        if (target) {
+          output.push(
+            relation(
+              from,
+              "depends-on",
+              target.id,
+              context,
+              type,
+              target.exact ? 1 : 0.35,
+              target.exact ? "TypeScript heritage resolution" : "unresolved heritage syntax"
+            )
+          );
+        }
+      }
+    }
+  }
+}
+function resolveExpressionTarget(context, expression, allowFallback = true) {
+  let symbol = context.checker.getSymbolAtLocation(expression);
+  if (!symbol && ts2.isPropertyAccessExpression(expression)) {
+    symbol = context.checker.getSymbolAtLocation(expression.name);
+  }
+  const externalBinding = importedExpressionBinding(context, expression);
+  if (!symbol) {
+    const imported = resolveImportedExpressionTarget(context, expression);
+    if (imported) return { id: imported, exact: true };
+    if (externalBinding) {
+      return {
+        id: externalId(externalBinding.module, externalBinding.exported),
+        exact: true
+      };
+    }
+    const fallback2 = allowFallback ? expressionFallbackId(expression) : void 0;
+    return fallback2 ? { id: fallback2, exact: false } : void 0;
+  }
+  if (symbol.flags & ts2.SymbolFlags.Alias) {
+    try {
+      symbol = context.checker.getAliasedSymbol(symbol);
+    } catch {
+    }
+  }
+  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  if (!declaration) {
+    const imported = resolveImportedExpressionTarget(context, expression);
+    if (imported) return { id: imported, exact: true };
+    if (externalBinding) {
+      return {
+        id: externalId(externalBinding.module, externalBinding.exported),
+        exact: true
+      };
+    }
+    const fallback2 = allowFallback ? expressionFallbackId(expression) : void 0;
+    return fallback2 ? { id: fallback2, exact: false } : void 0;
+  }
+  const source = declaration.getSourceFile();
+  if (!isPathInside(context.root, source.fileName)) {
+    return externalBinding ? {
+      id: externalId(externalBinding.module, externalBinding.exported),
+      exact: true
+    } : allowFallback ? { id: externalId("unresolved", symbol.getName()), exact: false } : void 0;
+  }
+  const relative = relativePosix(context.root, source.fileName);
+  if (context.indexedSourcePaths && !context.indexedSourcePaths.has(relative)) {
+    return externalBinding ? {
+      id: externalId(externalBinding.module, externalBinding.exported),
+      exact: true
+    } : allowFallback ? { id: externalId("unresolved", symbol.getName()), exact: false } : void 0;
+  }
+  const id = declarationToId(declaration, relative);
+  if (id) return { id, exact: true };
+  if (externalBinding) {
+    return {
+      id: externalId(externalBinding.module, externalBinding.exported),
+      exact: true
+    };
+  }
+  const fallback = allowFallback ? expressionFallbackId(expression) : void 0;
+  return fallback ? { id: fallback, exact: false } : void 0;
+}
+function resolveImportedExpressionTarget(context, expression) {
+  const binding = importedExpressionBinding(context, expression, true);
+  if (!binding?.resolved) return void 0;
+  if (ts2.isIdentifier(expression)) {
+    const sourceFile2 = context.program.getSourceFile(path4.resolve(context.root, binding.resolved));
+    if (!sourceFile2) return void 0;
+    const declaration2 = findExportedDeclaration(sourceFile2, binding.imported);
+    return declaration2 ? declarationToId(declaration2, binding.resolved) : void 0;
+  }
+  if (!ts2.isPropertyAccessExpression(expression)) return void 0;
+  const sourceFile = context.program.getSourceFile(path4.resolve(context.root, binding.resolved));
+  if (!sourceFile) return void 0;
+  const declaration = findExportedDeclaration(sourceFile, expression.name.text);
+  return declaration ? declarationToId(declaration, binding.resolved) : void 0;
+}
+function findExportedDeclaration(sourceFile, exportedName) {
+  for (const statement of sourceFile.statements) {
+    if ((ts2.isFunctionDeclaration(statement) || ts2.isClassDeclaration(statement) || ts2.isInterfaceDeclaration(statement) || ts2.isTypeAliasDeclaration(statement)) && (exportedName === "default" && hasDefaultModifier(statement) || statement.name?.text === exportedName)) {
+      return statement;
+    }
+    if (ts2.isVariableStatement(statement)) {
+      const declaration = statement.declarationList.declarations.find(
+        (item) => ts2.isIdentifier(item.name) && item.name.text === exportedName
+      );
+      if (declaration) return declaration;
+    }
+    if (ts2.isExportAssignment(statement) && !statement.isExportEquals && ts2.isIdentifier(statement.expression)) {
+      if (exportedName === "default") {
+        const declaration = findDeclarationByName(sourceFile, statement.expression.text);
+        if (declaration) return declaration;
+      }
+      if (statement.expression.text === exportedName) {
+        return findDeclarationByName(sourceFile, statement.expression.text);
+      }
+    }
+    if (ts2.isExportDeclaration(statement) && statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
+      const specifier = statement.exportClause.elements.find(
+        (item) => item.name.text === exportedName
+      );
+      if (specifier && !statement.moduleSpecifier) {
+        return findExportedDeclaration(
+          sourceFile,
+          specifier.propertyName?.text ?? specifier.name.text
+        );
+      }
+    }
+  }
+  return void 0;
+}
+function findDeclarationByName(sourceFile, name) {
+  for (const statement of sourceFile.statements) {
+    if ((ts2.isFunctionDeclaration(statement) || ts2.isClassDeclaration(statement) || ts2.isInterfaceDeclaration(statement) || ts2.isTypeAliasDeclaration(statement)) && statement.name?.text === name) {
+      return statement;
+    }
+    if (ts2.isVariableStatement(statement)) {
+      const declaration = statement.declarationList.declarations.find(
+        (item) => ts2.isIdentifier(item.name) && item.name.text === name
+      );
+      if (declaration) return declaration;
+    }
+  }
+  return void 0;
+}
+function importedExpressionBinding(context, expression, includeLocal = false) {
+  const root = leftMostIdentifierNode(expression);
+  if (!root) return void 0;
+  const rootSymbol = context.checker.getSymbolAtLocation(root);
+  if (!rootSymbol) return void 0;
+  const declaration = rootSymbol.declarations?.find(isImportBindingDeclaration);
+  if (!declaration) return void 0;
+  const importDeclaration = enclosingImportDeclaration(declaration);
+  if (!importDeclaration || !ts2.isStringLiteral(importDeclaration.moduleSpecifier))
+    return void 0;
+  const source = sanitizeModuleSpecifier(importDeclaration.moduleSpecifier.text);
+  const line = nodeLine(context.sourceFile, importDeclaration);
+  const imported = context.file.imports.find(
+    (record) => record.kind === "esm" && record.source === source && record.line === line && record.specifiers.some((specifier2) => specifier2.local === root.text)
+  );
+  if (!imported || !includeLocal && !imported.external) return void 0;
+  const specifier = imported.specifiers.find((item) => item.local === root.text);
+  if (!specifier) return void 0;
+  return {
+    module: imported.source,
+    exported: ts2.isPropertyAccessExpression(expression) ? expression.name.text : specifier.imported,
+    imported: specifier.imported,
+    ...imported.resolved ? { resolved: imported.resolved } : {}
+  };
+}
+function isImportBindingDeclaration(declaration) {
+  return ts2.isImportSpecifier(declaration) || ts2.isImportClause(declaration) || ts2.isNamespaceImport(declaration);
+}
+function enclosingImportDeclaration(declaration) {
+  let current = declaration;
+  while (!ts2.isSourceFile(current)) {
+    if (ts2.isImportDeclaration(current)) return current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function declarationToId(declaration, filePath) {
+  if (ts2.isFunctionDeclaration(declaration)) {
+    return symbolId("function", filePath, declaration.name?.text ?? "default");
+  }
+  if (ts2.isClassDeclaration(declaration)) {
+    return symbolId("class", filePath, declaration.name?.text ?? "default");
+  }
+  if (ts2.isMethodDeclaration(declaration)) {
+    const parent = declaration.parent;
+    const parentName = ts2.isClassDeclaration(parent) || ts2.isInterfaceDeclaration(parent) ? parent.name?.text ?? "default" : "anonymous";
+    return symbolId(
+      "method",
+      filePath,
+      propertyNameText(declaration.name) ?? "anonymous",
+      parentName
+    );
+  }
+  if (ts2.isVariableDeclaration(declaration)) {
+    const name = getDeclarationName(declaration);
+    const kind = declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer)) ? "function" : "variable";
+    return symbolId(kind, filePath, name);
+  }
+  if (ts2.isInterfaceDeclaration(declaration))
+    return symbolId("interface", filePath, declaration.name.text);
+  if (ts2.isTypeAliasDeclaration(declaration))
+    return symbolId("type-alias", filePath, declaration.name.text);
+  return void 0;
+}
+function isReferenceIdentifier(node) {
+  const parent = node.parent;
+  if (parent.name === node || ts2.isImportSpecifier(parent) || ts2.isImportClause(parent) || ts2.isNamespaceImport(parent) || ts2.isExportSpecifier(parent) || ts2.isBindingElement(parent) || ts2.isPropertyAccessExpression(parent) && parent.name === node || ts2.isPropertyAssignment(parent) && parent.name === node || ts2.isPropertySignature(parent) && parent.name === node || ts2.isPropertyDeclaration(parent) && parent.name === node || ts2.isMethodDeclaration(parent) && parent.name === node) {
+    return false;
+  }
+  return true;
+}
+function expressionFallbackId(expression) {
+  if (ts2.isIdentifier(expression)) return externalId("unresolved", expression.text);
+  if (ts2.isPropertyAccessExpression(expression)) {
+    return externalId("unresolved", expression.name.text);
+  }
+  return void 0;
+}
+function leftMostIdentifierNode(expression) {
+  let current = expression;
+  while (ts2.isPropertyAccessExpression(current)) current = current.expression;
+  return ts2.isIdentifier(current) ? current : void 0;
+}
+function extractFileStructure(context) {
+  const imports = [];
+  const exports = [];
+  const env = /* @__PURE__ */ new Set();
+  const operations = [];
+  const diagnostics = [];
+  const relations = [];
+  const importedModules = /* @__PURE__ */ new Map();
+  for (const statement of context.sourceFile.statements) {
+    if (ts2.isImportDeclaration(statement) && ts2.isStringLiteral(statement.moduleSpecifier)) {
+      const rawSource = statement.moduleSpecifier.text;
+      const source = sanitizeModuleSpecifier(rawSource);
+      const specifiers = importSpecifiers(statement);
+      for (const specifier of specifiers) importedModules.set(specifier.local, source);
+      const resolved = resolveImport(context, rawSource);
+      imports.push({
+        source,
+        specifiers,
+        ...resolved.path ? { resolved: resolved.path } : {},
+        external: resolved.external,
+        kind: "esm",
+        line: nodeLine(context.sourceFile, statement)
+      });
+      addImportRelation(context, relations, statement, source, resolved);
+      if (!resolved.found && !isBuiltin(rawSource))
+        diagnostics.push(unresolvedImport(context, statement, source));
+    } else if (ts2.isExportDeclaration(statement)) {
+      extractExportDeclaration(context, statement, exports, relations);
+    } else if (ts2.isExportAssignment(statement)) {
+      exports.push({
+        name: "default",
+        local: ts2.isIdentifier(statement.expression) ? statement.expression.text : "default",
+        default: true,
+        line: nodeLine(context.sourceFile, statement)
+      });
+    }
+  }
+  visit(context.sourceFile, (node) => {
+    if (ts2.isCallExpression(node) && isRequireCall(node)) {
+      const argument = node.arguments[0];
+      if (!argument || !ts2.isStringLiteral(argument)) return;
+      const rawSource = argument.text;
+      const source = sanitizeModuleSpecifier(rawSource);
+      const resolved = resolveImport(context, rawSource);
+      imports.push({
+        source,
+        specifiers: [],
+        ...resolved.path ? { resolved: resolved.path } : {},
+        external: resolved.external,
+        kind: "commonjs",
+        line: nodeLine(context.sourceFile, node)
+      });
+      addImportRelation(context, relations, node, source, resolved);
+      if (!resolved.found && !isBuiltin(rawSource))
+        diagnostics.push(unresolvedImport(context, node, source));
+    }
+    const envName = processEnvName(node);
+    if (envName) env.add(envName);
+    const operation = externalOperation(node, context.sourceFile, importedModules);
+    if (operation) operations.push(operation);
+  });
+  extractCommonJsExports(context, exports);
+  return {
+    imports: dedupeImports(imports),
+    exports: dedupeExports(exports),
+    env: [...env].sort(compareText),
+    operations: dedupeOperations(operations),
+    diagnostics,
+    relations
+  };
+}
+function importSpecifiers(statement) {
+  const clause = statement.importClause;
+  if (!clause) return [];
+  const output = [];
+  const clauseTypeOnly = clause.phaseModifier === ts2.SyntaxKind.TypeKeyword;
+  if (clause.name) {
+    output.push({
+      imported: "default",
+      local: clause.name.text,
+      ...clauseTypeOnly ? { typeOnly: true } : {}
+    });
+  }
+  const bindings = clause.namedBindings;
+  if (bindings && ts2.isNamespaceImport(bindings)) {
+    output.push({
+      imported: "*",
+      local: bindings.name.text,
+      ...clauseTypeOnly ? { typeOnly: true } : {}
+    });
+  } else if (bindings && ts2.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      output.push({
+        imported: element.propertyName?.text ?? element.name.text,
+        local: element.name.text,
+        ...clauseTypeOnly || element.isTypeOnly ? { typeOnly: true } : {}
+      });
+    }
+  }
+  return output.sort((a, b) => compareText(`${a.imported}:${a.local}`, `${b.imported}:${b.local}`));
+}
+function extractExportDeclaration(context, statement, exports, relations) {
+  const rawSource = statement.moduleSpecifier && ts2.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : void 0;
+  const source = rawSource ? sanitizeModuleSpecifier(rawSource) : void 0;
+  const line = nodeLine(context.sourceFile, statement);
+  if (!statement.exportClause) {
+    exports.push({ name: "*", ...source ? { source } : {}, default: false, line });
+  } else if (ts2.isNamespaceExport(statement.exportClause)) {
+    exports.push({
+      name: statement.exportClause.name.text,
+      ...source ? { source } : {},
+      default: false,
+      line
+    });
+  } else {
+    for (const element of statement.exportClause.elements) {
+      exports.push({
+        name: element.name.text,
+        local: element.propertyName?.text ?? element.name.text,
+        ...source ? { source } : {},
+        default: element.name.text === "default",
+        ...statement.isTypeOnly || element.isTypeOnly ? { typeOnly: true } : {},
+        line
+      });
+    }
+  }
+  if (rawSource && source) {
+    const resolved = resolveImport(context, rawSource);
+    relations.push(
+      relation(
+        fileId(context.relativePath),
+        "reexports",
+        resolved.path ? fileId(resolved.path) : externalId(source),
+        context,
+        statement,
+        resolved.found ? 1 : 0.5,
+        resolved.found ? "resolved re-export" : "unresolved re-export"
+      )
+    );
+  }
+}
+function extractCommonJsExports(context, exports) {
+  visit(context.sourceFile, (node) => {
+    if (!ts2.isBinaryExpression(node) || node.operatorToken.kind !== ts2.SyntaxKind.EqualsToken)
+      return;
+    const left = node.left;
+    const line = nodeLine(context.sourceFile, node);
+    if (ts2.isPropertyAccessExpression(left) && ts2.isIdentifier(left.expression) && left.expression.text === "module" && left.name.text === "exports") {
+      exports.push({
+        name: "default",
+        ...ts2.isIdentifier(node.right) ? { local: node.right.text } : {},
+        default: true,
+        line
+      });
+    } else if (ts2.isPropertyAccessExpression(left) && (ts2.isIdentifier(left.expression) && left.expression.text === "exports" || ts2.isPropertyAccessExpression(left.expression) && ts2.isIdentifier(left.expression.expression) && left.expression.expression.text === "module" && left.expression.name.text === "exports")) {
+      exports.push({
+        name: left.name.text,
+        local: ts2.isIdentifier(node.right) ? node.right.text : left.name.text,
+        default: false,
+        line
+      });
+    }
+  });
+}
+function resolveImport(context, moduleName) {
+  if (isBuiltin(moduleName) || moduleName.startsWith("node:"))
+    return { found: true, external: true };
+  const resolution = context.resolveModule?.(moduleName, context.sourceFile.fileName);
+  if (!resolution) return { found: false, external: !moduleName.startsWith(".") };
+  if (resolution.isExternalLibraryImport) return { found: true, external: true };
+  if (!isPathInside(context.root, resolution.resolvedFileName)) {
+    return { found: true, external: true };
+  }
+  const relative = relativePosix(context.root, resolution.resolvedFileName);
+  if (context.indexedSourcePaths && !context.indexedSourcePaths.has(relative)) {
+    return { found: false, external: false };
+  }
+  return {
+    found: true,
+    external: false,
+    path: relative
+  };
+}
+function addImportRelation(context, output, node, source, resolved) {
+  output.push(
+    relation(
+      fileId(context.relativePath),
+      "imports",
+      resolved.path ? fileId(resolved.path) : externalId(source),
+      context,
+      node,
+      resolved.found ? 1 : 0.5,
+      resolved.found ? "module resolution" : "unresolved import text"
+    )
+  );
+}
+function unresolvedImport(context, node, source) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    code: "unresolved-import",
+    severity: "warning",
+    message: `Could not resolve import ${source}.`,
+    file: context.relativePath,
+    line: nodeLine(context.sourceFile, node)
+  };
+}
+function processEnvName(node) {
+  if (ts2.isPropertyAccessExpression(node) && ts2.isPropertyAccessExpression(node.expression) && ts2.isIdentifier(node.expression.expression) && node.expression.expression.text === "process" && node.expression.name.text === "env") {
+    return node.name.text;
+  }
+  if (ts2.isElementAccessExpression(node) && ts2.isPropertyAccessExpression(node.expression) && ts2.isIdentifier(node.expression.expression) && node.expression.expression.text === "process" && node.expression.name.text === "env" && ts2.isStringLiteral(node.argumentExpression)) {
+    return node.argumentExpression.text;
+  }
+  return void 0;
+}
+function externalOperation(node, sourceFile, importedModules) {
+  if (!ts2.isCallExpression(node)) return void 0;
+  let root;
+  let api;
+  if (ts2.isIdentifier(node.expression)) {
+    root = node.expression.text;
+    api = root;
+  } else if (ts2.isPropertyAccessExpression(node.expression)) {
+    root = leftMostIdentifierNode(node.expression)?.text;
+    api = node.expression.getText(sourceFile);
+  } else return void 0;
+  const source = root ? importedModules.get(root) : void 0;
+  let kind;
+  if (root === "fetch" || source === "axios" || source === "http" || source === "https" || source?.startsWith("node:http"))
+    kind = "http";
+  else if (source === "fs" || source === "fs/promises" || source?.startsWith("node:fs"))
+    kind = "filesystem";
+  else if (source && /(?:prisma|typeorm|mongoose|sequelize|pg|mysql|database|redis)/i.test(source))
+    kind = "database";
+  else if (source && /(?:bull|queue|kafka|amqp|rabbit)/i.test(source)) kind = "queue";
+  return kind ? { kind, api, line: nodeLine(sourceFile, node) } : void 0;
+}
+function isRequireCall(node) {
+  return ts2.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length > 0;
+}
+function dedupeImports(values) {
+  const map = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    map.set(`${value.kind}:${value.source}:${value.line}`, value);
+  }
+  return [...map.values()].sort(
+    (a, b) => compareText(`${a.source}:${a.line}`, `${b.source}:${b.line}`)
+  );
+}
+function dedupeExports(values) {
+  const map = /* @__PURE__ */ new Map();
+  for (const value of values) map.set(`${value.name}:${value.source ?? ""}:${value.line}`, value);
+  return [...map.values()].sort(
+    (a, b) => compareText(`${a.name}:${a.line}`, `${b.name}:${b.line}`)
+  );
+}
+function dedupeOperations(values) {
+  const map = /* @__PURE__ */ new Map();
+  for (const value of values) map.set(`${value.kind}:${value.api}:${value.line}`, value);
+  return [...map.values()].sort(
+    (a, b) => compareText(`${a.kind}:${a.line}:${a.api}`, `${b.kind}:${b.line}:${b.api}`)
+  );
+}
+function relation(from, type, to, context, node, confidence, explanation) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    from,
+    type,
+    to,
+    confidence,
+    origin: {
+      file: context.relativePath,
+      line: nodeLine(context.sourceFile, node),
+      range: nodeRange(context.sourceFile, node),
+      explanation,
+      classification: confidence === 1 ? "exact" : "heuristic",
+      analyzer: "typescript-node"
+    }
+  };
+}
+
+// src/analyzers/nestjs.ts
+import ts3 from "typescript";
+var METHOD_DECORATORS = /* @__PURE__ */ new Set([
+  "Get",
+  "Post",
+  "Put",
+  "Patch",
+  "Delete",
+  "Head",
+  "Options",
+  "All"
+]);
+var NEST_DECORATORS = /* @__PURE__ */ new Set([
+  "Module",
+  "Controller",
+  "Injectable",
+  "Guard",
+  "UseGuards",
+  "Body",
+  "Param",
+  ...METHOD_DECORATORS
+]);
+var registeredNestJsAnalyzers = /* @__PURE__ */ new WeakSet();
+var NestJsAnalyzer = class {
+  name = "nestjs";
+  version = "0.1.0-experimental";
+  constructor() {
+    registeredNestJsAnalyzers.add(this);
+  }
+  supports(context) {
+    if (!context.relativePath.endsWith(".ts")) return false;
+    return hasAnyNestImport(context.sourceFile) || containsReferencedBodyDto(context);
+  }
+  analyze(context) {
+    const symbols = [];
+    const relations = [];
+    const bodyDtoSymbolIds = collectBodyDtoSymbolIds(context);
+    const aliases = collectImportAliases(context.sourceFile);
+    const moduleMembership = collectModuleMembership(context);
+    for (const statement of context.sourceFile.statements) {
+      if (!ts3.isClassDeclaration(statement) || !statement.name) continue;
+      const className = statement.name.text;
+      const decoratorNames = collectDecoratorNames(decoratorsOf(statement), aliases);
+      const kind = classifyClass(
+        className,
+        decoratorNames,
+        symbolId("dto", context.relativePath, className),
+        bodyDtoSymbolIds
+      );
+      if (kind === "dto") {
+        symbols.push(
+          makeSymbol(context, statement, "dto", {
+            name: className,
+            exported: hasExportModifier(statement),
+            defaultExport: hasDefaultModifier(statement),
+            facts: {
+              name: className.toLowerCase(),
+              kind: "dto"
+            }
+          })
+        );
+        continue;
+      }
+      if (!kind) continue;
+      const symbol = makeSymbol(context, statement, kind, {
+        name: className,
+        exported: hasExportModifier(statement),
+        defaultExport: hasDefaultModifier(statement),
+        facts: {
+          name: className.toLowerCase(),
+          kind
+        }
+      });
+      symbols.push(symbol);
+      if (kind === "nest-module") {
+        const metadata = collectModuleMetadata(statement, aliases);
+        if (metadata.controllers.length > 0) {
+          symbol.facts.controllers = compactText(metadata.controllers.join(","));
+          for (const controller of metadata.controllers) {
+            const controllerId = resolveLocalClassId(context, controller, "nest-controller");
+            if (!controllerId) continue;
+            relations.push(
+              makeRelation(
+                symbol.id,
+                "contains",
+                controllerId,
+                context,
+                statement,
+                1,
+                "module controller"
+              )
+            );
+          }
+        }
+        if (metadata.providers.length > 0) {
+          symbol.facts.providers = compactText(metadata.providers.join(","));
+          for (const provider of metadata.providers) {
+            const providerId = resolveLocalClassId(context, provider, "nest-provider");
+            if (!providerId) continue;
+            relations.push(
+              makeRelation(
+                symbol.id,
+                "contains",
+                providerId,
+                context,
+                statement,
+                1,
+                "module provider"
+              )
+            );
+          }
+        }
+        if (metadata.imports.length > 0) {
+          symbol.facts.imports = compactText(metadata.imports.join(","));
+        }
+        if (metadata.exports.length > 0) {
+          symbol.facts.exports = compactText(metadata.exports.join(","));
+        }
+      }
+      if (kind === "nest-controller") {
+        const baseRoute = collectControllerRoute(statement, aliases);
+        symbol.facts.baseRoute = baseRoute;
+        symbol.facts.kind = "controller";
+        const controllerRoutes = collectControllerMethods(context, statement, className, aliases);
+        relations.push(...controllerRoutes.relations);
+        if (controllerRoutes.summary.length > 0) {
+          symbol.facts.routes = compactText(controllerRoutes.summary.join(","));
+        }
+        const guards = collectClassUseGuards(statement, aliases);
+        if (guards.length > 0) {
+          symbol.facts.guards = compactText(guards.join(","));
+        }
+      }
+      for (const injected of collectConstructorInjections(context, statement)) {
+        relations.push(
+          makeRelation(
+            symbol.id,
+            "injects",
+            injected,
+            context,
+            statement,
+            1,
+            "constructor injection"
+          )
+        );
+      }
+      const moduleId = moduleMembership.get(className);
+      if (moduleId) {
+        relations.push(
+          makeRelation(
+            symbol.id,
+            "belongs-to-module",
+            moduleId,
+            context,
+            statement,
+            1,
+            "module membership"
+          )
+        );
+      }
+    }
+    return { symbols, relations, frameworks: ["nestjs"] };
+  }
+};
+var nestJsSupports = NestJsAnalyzer.prototype.supports.bind(NestJsAnalyzer.prototype);
+var nestJsAnalyze = NestJsAnalyzer.prototype.analyze.bind(NestJsAnalyzer.prototype);
+function trustedNestJsAnalyzerMethods(analyzer) {
+  if (!registeredNestJsAnalyzers.has(analyzer)) return void 0;
+  if (Object.getPrototypeOf(analyzer) !== NestJsAnalyzer.prototype) return void 0;
+  if (Object.hasOwn(analyzer, "supports") || Object.hasOwn(analyzer, "analyze")) {
+    return void 0;
+  }
+  const name = Object.getOwnPropertyDescriptor(analyzer, "name");
+  const version = Object.getOwnPropertyDescriptor(analyzer, "version");
+  if (name?.value !== "nestjs" || version?.value !== "0.1.0-experimental") return void 0;
+  return {
+    supports: (context) => nestJsSupports(context),
+    analyze: (context) => nestJsAnalyze(context)
+  };
+}
+function hasAnyNestImport(sourceFile) {
+  return sourceFile.statements.some(
+    (statement) => ts3.isImportDeclaration(statement) && ts3.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text.startsWith("@nestjs/")
+  );
+}
+function collectImportAliases(sourceFile) {
+  const aliases = {
+    named: {},
+    namespaces: /* @__PURE__ */ new Set()
+  };
+  for (const statement of sourceFile.statements) {
+    if (!ts3.isImportDeclaration(statement) || !ts3.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (!statement.moduleSpecifier.text.startsWith("@nestjs/")) continue;
+    const clause = statement.importClause;
+    if (!clause || !clause.namedBindings) continue;
+    if (ts3.isNamespaceImport(clause.namedBindings)) {
+      aliases.namespaces.add(clause.namedBindings.name.text);
+      continue;
+    }
+    if (!ts3.isNamedImports(clause.namedBindings)) continue;
+    for (const item of clause.namedBindings.elements) {
+      aliases.named[item.name.text] = item.propertyName ? item.propertyName.text : item.name.text;
+    }
+  }
+  return aliases;
+}
+function classifyClass(className, decorators, symbolIdValue, dtoSymbolIds) {
+  if (dtoSymbolIds.has(symbolIdValue)) return "dto";
+  if (decorators.includes("Module")) return "nest-module";
+  if (decorators.includes("Controller")) return "nest-controller";
+  if (!decorators.includes("Injectable")) return void 0;
+  if (className.endsWith("Guard")) return "nest-guard";
+  if (className.endsWith("Interceptor")) return "nest-interceptor";
+  if (className.endsWith("Pipe")) return "nest-pipe";
+  if (className.endsWith("Filter")) return "nest-filter";
+  if (className.endsWith("Gateway")) return "nest-gateway";
+  return "nest-provider";
+}
+function collectDecoratorNames(decorators, aliases) {
+  const names = [];
+  for (const decorator of decorators) {
+    const name = resolveDecoratorName(decorator.expression, aliases);
+    if (name && NEST_DECORATORS.has(name)) {
+      names.push(name);
+    }
+  }
+  return names;
+}
+function resolveDecoratorName(expression, aliases) {
+  const target = ts3.isCallExpression(expression) ? expression.expression : expression;
+  if (ts3.isIdentifier(target)) {
+    const resolved = aliases.named[target.text];
+    if (resolved) return resolved;
+    return void 0;
+  }
+  if (ts3.isPropertyAccessExpression(target) && ts3.isIdentifier(target.expression)) {
+    if (aliases.namespaces.has(target.expression.text)) return target.name.text;
+  }
+  return void 0;
+}
+function collectControllerRoute(classNode, aliases) {
+  for (const decorator of decoratorsOf(classNode)) {
+    const expression = decorator.expression;
+    const call = ts3.isCallExpression(expression) ? expression : void 0;
+    if (!call) continue;
+    const name = resolveDecoratorName(expression, aliases);
+    if (!name) continue;
+    if (name !== "Controller") continue;
+    const arg = call.arguments[0];
+    if (!arg) return "/";
+    if (ts3.isStringLiteral(arg) || ts3.isNoSubstitutionTemplateLiteral(arg)) {
+      const value = arg.text.trim();
+      return value.startsWith("/") ? value : `/${value}`;
+    }
+  }
+  return "/";
+}
+function collectControllerMethods(context, controller, className, aliases) {
+  const relations = [];
+  const summary = [];
+  const baseRoute = collectControllerRoute(controller, aliases);
+  for (const member of controller.members) {
+    if (!ts3.isMethodDeclaration(member) || !ts3.isIdentifier(member.name)) continue;
+    const methodName = member.name.text;
+    const methodDecorators = collectDecoratorNames(decoratorsOf(member), aliases);
+    const methodVerbs = methodDecorators.filter((name) => METHOD_DECORATORS.has(name));
+    if (methodVerbs.length === 0) continue;
+    const methodRoute = collectMethodRoute(member, aliases);
+    const fullRoute = combineRoutes(baseRoute, methodRoute);
+    for (const verb of methodVerbs) {
+      const lower = verb.toLowerCase();
+      const methodId = symbolId("method", context.relativePath, methodName, className);
+      relations.push(
+        makeRelation(
+          methodId,
+          "handles-route",
+          routeId(lower, fullRoute),
+          context,
+          member,
+          1,
+          "http method route"
+        )
+      );
+      summary.push(`${lower} ${fullRoute}`);
+      const dto = collectBodyDto(member, aliases, context);
+      if (dto) {
+        relations.push(
+          makeRelation(methodId, "consumes-dto", dto, context, member, 1, "dto usage")
+        );
+      }
+    }
+  }
+  return { relations, summary: dedupe(summary) };
+  function collectMethodRoute(methodNode, aliasesMap) {
+    for (const decorator of decoratorsOf(methodNode)) {
+      const expression = decorator.expression;
+      const call = ts3.isCallExpression(expression) ? expression : void 0;
+      if (!call) continue;
+      const name = resolveDecoratorName(expression, aliasesMap);
+      if (!name) continue;
+      if (!METHOD_DECORATORS.has(name)) continue;
+      const arg = call.arguments[0];
+      if (!arg) return "/";
+      if (ts3.isStringLiteral(arg) || ts3.isNoSubstitutionTemplateLiteral(arg)) {
+        const route = arg.text.trim();
+        return route.startsWith("/") ? route : `/${route}`;
+      }
+    }
+    return "/";
+  }
+}
+function collectBodyDto(method, aliases, context) {
+  return collectBodyDtoFromMethod(method, aliases, context);
+}
+function collectBodyDtoSymbolIds(context) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const source of context.program.getSourceFiles().filter((source2) => !source2.isDeclarationFile)) {
+    if (!hasAnyNestImport(source)) continue;
+    const sourceRelative = relativeFromAbsolute(context.root, source.fileName);
+    if (!sourceRelative) continue;
+    const aliases = collectImportAliases(source);
+    for (const statement of source.statements) {
+      if (!ts3.isClassDeclaration(statement)) continue;
+      for (const member of statement.members) {
+        if (!ts3.isMethodDeclaration(member)) continue;
+        const dtoId = collectBodyDtoFromMethod(member, aliases, context);
+        if (dtoId) ids.add(dtoId);
+      }
+    }
+  }
+  return ids;
+}
+function collectBodyDtoFromMethod(method, aliases, context) {
+  const param = method.parameters.find((item) => hasDecorator(item, "Body", aliases));
+  if (!param?.type || !ts3.isTypeReferenceNode(param.type) || !ts3.isIdentifier(param.type.typeName))
+    return void 0;
+  const declaration = resolveIdentifierDeclaration(context, param.type.typeName);
+  if (!declaration || !ts3.isClassDeclaration(declaration) || !declaration.name) return void 0;
+  const relative = relativeFromRoot(context, declaration.getSourceFile().fileName);
+  if (!relative) return void 0;
+  return symbolId("dto", relative, declaration.name.text);
+}
+function containsReferencedBodyDto(context) {
+  const dtoIds = collectBodyDtoSymbolIds(context);
+  return context.sourceFile.statements.some(
+    (statement) => ts3.isClassDeclaration(statement) && statement.name !== void 0 && dtoIds.has(symbolId("dto", context.relativePath, statement.name.text))
+  );
+}
+function resolveIdentifierDeclaration(context, identifier) {
+  let symbol = context.checker.getSymbolAtLocation(identifier);
+  if (!symbol) return void 0;
+  if ((symbol.flags & ts3.SymbolFlags.Alias) !== 0) {
+    symbol = context.checker.getAliasedSymbol(symbol);
+  }
+  return symbol.valueDeclaration ?? symbol.declarations?.[0];
+}
+function resolveLocalClassId(context, localName, kind) {
+  const identifier = findTopLevelIdentifier(context.sourceFile, localName);
+  if (!identifier) return void 0;
+  const declaration = resolveIdentifierDeclaration(context, identifier);
+  if (!declaration || !ts3.isClassDeclaration(declaration) || !declaration.name) return void 0;
+  const relative = relativeFromRoot(context, declaration.getSourceFile().fileName);
+  if (!relative) return void 0;
+  return symbolId(kind, relative, declaration.name.text);
+}
+function findTopLevelIdentifier(sourceFile, localName) {
+  for (const statement of sourceFile.statements) {
+    if (ts3.isClassDeclaration(statement) && statement.name?.text === localName) {
+      return statement.name;
+    }
+    if (!ts3.isImportDeclaration(statement)) continue;
+    const clause = statement.importClause;
+    if (clause?.name?.text === localName) return clause.name;
+    if (!clause?.namedBindings || !ts3.isNamedImports(clause.namedBindings)) continue;
+    const match = clause.namedBindings.elements.find((item) => item.name.text === localName);
+    if (match) return match.name;
+  }
+  return void 0;
+}
+function relativeFromAbsolute(root, absolutePath) {
+  const normalized = absolutePath.replace(/\\/g, "/");
+  const normalizedRoot = root.replace(/\\/g, "/");
+  if (normalized !== normalizedRoot && !normalized.startsWith(`${normalizedRoot}/`))
+    return void 0;
+  const remainder = normalized.slice(normalizedRoot.length);
+  return remainder.startsWith("/") ? remainder.slice(1) : remainder;
+}
+function hasDecorator(parameter, target, aliases) {
+  for (const decorator of decoratorsOf(parameter)) {
+    const resolved = resolveDecoratorName(decorator.expression, aliases);
+    if (resolved === target) return true;
+  }
+  return false;
+}
+function collectConstructorInjections(context, classNode) {
+  const constructorNode = classNode.members.find(ts3.isConstructorDeclaration);
+  if (!constructorNode) return [];
+  const dependencies = [];
+  for (const parameter of constructorNode.parameters) {
+    if (!parameter.type || !ts3.isTypeReferenceNode(parameter.type) || !ts3.isIdentifier(parameter.type.typeName))
+      continue;
+    const declaration = resolveIdentifierDeclaration(context, parameter.type.typeName);
+    if (!declaration) continue;
+    const relative = relativeFromRoot(context, declaration.getSourceFile().fileName);
+    if (!relative) continue;
+    const targetName = ts3.isClassDeclaration(declaration) && declaration.name ? declaration.name.text : parameter.type.typeName.text;
+    dependencies.push(symbolId("nest-provider", relative, targetName));
+  }
+  return dedupe(dependencies);
+}
+function collectModuleMetadata(classNode, aliases) {
+  const defaults = { controllers: [], providers: [], imports: [], exports: [] };
+  for (const decorator of decoratorsOf(classNode)) {
+    const expression = decorator.expression;
+    const call = ts3.isCallExpression(expression) ? expression : void 0;
+    if (!call) continue;
+    const name = resolveDecoratorName(expression, aliases);
+    if (!name) continue;
+    if (name !== "Module" || call.arguments.length === 0) continue;
+    const arg = call.arguments[0];
+    if (!arg || !ts3.isObjectLiteralExpression(arg)) continue;
+    for (const property of arg.properties) {
+      if (!ts3.isPropertyAssignment(property) && !ts3.isShorthandPropertyAssignment(property))
+        continue;
+      const propertyName = ts3.isIdentifier(property.name) ? property.name.text : ts3.isStringLiteral(property.name) ? property.name.text : void 0;
+      if (!propertyName) continue;
+      if (!(propertyName in defaults)) continue;
+      const assigned = ts3.isPropertyAssignment(property) ? property.initializer : property.name;
+      if (propertyName === "controllers") {
+        defaults.controllers.push(...collectIdentifiers(assigned));
+      }
+      if (propertyName === "providers") {
+        defaults.providers.push(...collectIdentifiers(assigned));
+      }
+      if (propertyName === "imports") {
+        defaults.imports.push(...collectIdentifiers(assigned));
+      }
+      if (propertyName === "exports") {
+        defaults.exports.push(...collectIdentifiers(assigned));
+      }
+    }
+  }
+  return {
+    controllers: dedupe(defaults.controllers),
+    providers: dedupe(defaults.providers),
+    imports: dedupe(defaults.imports),
+    exports: dedupe(defaults.exports)
+  };
+}
+function collectIdentifiers(node) {
+  if (ts3.isIdentifier(node)) return [node.text];
+  if (ts3.isPropertyAccessExpression(node)) return [node.name.text];
+  if (ts3.isArrayLiteralExpression(node)) {
+    return node.elements.map(
+      (item) => ts3.isIdentifier(item) ? item.text : ts3.isPropertyAccessExpression(item) ? item.name.text : void 0
+    ).filter((value) => Boolean(value));
+  }
+  return [];
+}
+function collectModuleMembership(context) {
+  const mapping = /* @__PURE__ */ new Map();
+  for (const source of context.program.getSourceFiles().filter((file) => !file.isDeclarationFile)) {
+    const aliases = collectImportAliases(source);
+    for (const statement of source.statements) {
+      if (!ts3.isClassDeclaration(statement) || !statement.name) continue;
+      const decorators = collectDecoratorNames(decoratorsOf(statement), aliases);
+      if (!decorators.includes("Module")) continue;
+      const metadata = collectModuleMetadata(statement, aliases);
+      const moduleId = symbolId(
+        "nest-module",
+        relativeFromRoot(context, source.fileName) ?? context.relativePath,
+        statement.name.text
+      );
+      for (const child of [...metadata.controllers, ...metadata.providers]) {
+        mapping.set(child, moduleId);
+      }
+    }
+  }
+  return mapping;
+}
+function collectClassUseGuards(classNode, aliases) {
+  const names = [];
+  for (const decorator of decoratorsOf(classNode)) {
+    const expression = decorator.expression;
+    const call = ts3.isCallExpression(expression) ? expression : void 0;
+    if (!call) continue;
+    const name = resolveDecoratorName(expression, aliases);
+    if (!name) continue;
+    if (name !== "UseGuards") continue;
+    for (const arg of call.arguments) {
+      if (ts3.isIdentifier(arg)) names.push(arg.text);
+    }
+  }
+  return dedupe(names);
+}
+function dedupe(values) {
+  return [...new Set(values)];
+}
+function combineRoutes(base, child) {
+  const segments = [base, child].map((value) => value.replace(/^\/+|\/+$/g, "")).filter(Boolean);
+  return segments.length > 0 ? `/${segments.join("/")}` : "/";
+}
+function makeRelation(from, type, to, context, node, confidence, explanation) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    from,
+    type,
+    to,
+    confidence,
+    origin: {
+      file: context.relativePath,
+      line: nodeLine(context.sourceFile, node),
+      range: nodeRange(context.sourceFile, node),
+      explanation,
+      classification: confidence === 1 ? "framework-derived" : "heuristic",
+      analyzer: "nestjs"
+    }
+  };
+}
+function relativeFromRoot(context, absolutePath) {
+  const normalized = absolutePath.replace(/\\/g, "/");
+  const root = context.root.replace(/\\/g, "/");
+  if (normalized !== root && !normalized.startsWith(`${root}/`)) return void 0;
+  const remainder = normalized.slice(root.length);
+  return remainder.startsWith("/") ? remainder.slice(1) : remainder;
+}
+
+// src/analyzers/nextjs.ts
+import path5 from "path";
+import ts4 from "typescript";
+var ROUTE_GROUP_SEGMENT = /^\(.*\)$/;
+var ROUTE_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var APP_FILES_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var registeredNextJsAnalyzers = /* @__PURE__ */ new WeakSet();
+var NextJsAnalyzer = class {
+  name = "nextjs";
+  version = "0.1.0-experimental";
+  constructor() {
+    registeredNextJsAnalyzers.add(this);
+  }
+  supports(context) {
+    if (!APP_FILES_EXTENSIONS.has(path5.extname(context.relativePath).toLowerCase())) return false;
+    return context.relativePath.startsWith("app/") || context.relativePath.startsWith("pages/") || context.relativePath === "middleware.ts";
+  }
+  analyze(context) {
+    const sourceFile = context.sourceFile;
+    const route = parseNextRoute(context.relativePath);
+    const defaultExportNode = getTopLevelDefaultExportDeclaration(sourceFile);
+    const hasTopLevelExport = hasAnyTopLevelExport(sourceFile);
+    const symbols = [];
+    const relations = [];
+    if (!route) {
+      return { symbols, relations, frameworks: ["nextjs"] };
+    }
+    if (route.kind === "page") {
+      const pageFacts = pageFactsForRoute(context, route);
+      const symbol = makeSymbol(context, defaultExportNode ?? sourceFile, "next-page", {
+        name: defaultExportNode ? getDeclarationName(defaultExportNode, route.name) : route.name,
+        defaultExport: Boolean(defaultExportNode),
+        exported: hasTopLevelExport,
+        facts: pageFacts
+      });
+      symbols.push(symbol);
+      if (route.router === "app") {
+        for (const layout of collectContainingAppLayouts(context.relativePath, context)) {
+          relations.push(
+            makeRelation2(
+              symbol.id,
+              "uses-layout",
+              symbolId("next-layout", layout, "layout"),
+              context,
+              sourceFile,
+              1,
+              "app route layout chain"
+            )
+          );
+        }
+      }
+      return { symbols, relations, frameworks: ["nextjs"] };
+    }
+    if (route.kind === "layout") {
+      symbols.push(
+        makeSymbol(context, defaultExportNode ?? sourceFile, "next-layout", {
+          exported: hasTopLevelExport,
+          defaultExport: Boolean(defaultExportNode),
+          name: "layout",
+          facts: {
+            router: route.router,
+            route: route.route,
+            runtime: runtimeFromSource(sourceFile),
+            params: route.params.join(","),
+            metadata: compactText(collectMetadataMarkers(sourceFile).join(","))
+          }
+        })
+      );
+      return { symbols, relations, frameworks: ["nextjs"] };
+    }
+    if (route.kind === "route") {
+      const methods = collectRouteMethods(sourceFile);
+      symbols.push(
+        makeSymbol(context, sourceFile, "next-route-handler", {
+          exported: hasTopLevelExport,
+          name: "route-handler",
+          facts: {
+            router: route.router,
+            route: route.route,
+            methods,
+            runtime: runtimeFromSource(sourceFile),
+            metadata: compactText(collectMetadataMarkers(sourceFile).join(","))
+          }
+        })
+      );
+      return { symbols, relations, frameworks: ["nextjs"] };
+    }
+    symbols.push(
+      makeSymbol(context, sourceFile, "next-special-file", {
+        exported: hasTopLevelExport,
+        name: route.name,
+        facts: {
+          router: route.router,
+          route: route.route,
+          runtime: runtimeFromSource(sourceFile)
+        }
+      })
+    );
+    return { symbols, relations, frameworks: ["nextjs"] };
+  }
+};
+var nextJsSupports = NextJsAnalyzer.prototype.supports.bind(NextJsAnalyzer.prototype);
+var nextJsAnalyze = NextJsAnalyzer.prototype.analyze.bind(NextJsAnalyzer.prototype);
+function trustedNextJsAnalyzerMethods(analyzer) {
+  if (!registeredNextJsAnalyzers.has(analyzer)) return void 0;
+  if (Object.getPrototypeOf(analyzer) !== NextJsAnalyzer.prototype) return void 0;
+  if (Object.hasOwn(analyzer, "supports") || Object.hasOwn(analyzer, "analyze")) {
+    return void 0;
+  }
+  const name = Object.getOwnPropertyDescriptor(analyzer, "name");
+  const version = Object.getOwnPropertyDescriptor(analyzer, "version");
+  if (name?.value !== "nextjs" || version?.value !== "0.1.0-experimental") return void 0;
+  return {
+    supports: (context) => nextJsSupports(context),
+    analyze: (context) => nextJsAnalyze(context)
+  };
+}
+function parseNextRoute(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  if (!normalized.startsWith("app/") && !normalized.startsWith("pages/")) return void 0;
+  const router = normalized.startsWith("app/") ? "app" : "pages";
+  const segments = normalized.split("/").filter(Boolean);
+  const fileName = segments.at(-1);
+  if (!fileName) return void 0;
+  const fileBase = fileName.replace(/\.(ts|tsx|js|jsx)$/, "");
+  if (router === "app") {
+    const routeSegments2 = segments.slice(1, -1);
+    const baseRoute = buildRouteFromSegments(routeSegments2);
+    if (fileBase === "layout") {
+      return {
+        router,
+        kind: "layout",
+        route: baseRoute,
+        name: "layout",
+        params: dynamicSegmentNames(routeSegments2)
+      };
+    }
+    if (fileBase === "page") {
+      return {
+        router,
+        kind: "page",
+        route: baseRoute,
+        name: baseRoute.split("/")[baseRoute.split("/").length - 1] || "page",
+        params: dynamicSegmentNames(routeSegments2)
+      };
+    }
+    if (fileBase === "route") {
+      return {
+        router,
+        kind: "route",
+        route: baseRoute,
+        name: "route",
+        params: dynamicSegmentNames(routeSegments2)
+      };
+    }
+    if (fileBase.startsWith("_")) {
+      return {
+        router,
+        kind: "special",
+        route: "/_" + fileBase.replace(/^_/, ""),
+        name: fileName,
+        params: []
+      };
+    }
+    return void 0;
+  }
+  const pageSegments = segments.slice(1);
+  if (pageSegments.length === 0) return void 0;
+  const isApi = pageSegments[0] === "api";
+  const routeSegments = pageSegments.slice(0, pageSegments.length - 1);
+  const route = `/${buildRouteFromSegments([...routeSegments, fileBase === "index" ? "" : fileBase].filter(Boolean)).replace(/^\//, "")}`;
+  return {
+    router,
+    kind: isApi ? "route" : "page",
+    route,
+    name: route.split("/")[route.split("/").length - 1] || "page",
+    params: [...routeSegments, fileBase].filter(isDynamicSegment).map(stripDynamicMarkers)
+  };
+}
+function pageFactsForRoute(context, route) {
+  const markers = compactText(collectMetadataMarkers(context.sourceFile).join(","));
+  return {
+    router: route.router,
+    route: route.route,
+    params: route.params.join(","),
+    runtime: runtimeFromSource(context.sourceFile),
+    metadata: markers
+  };
+}
+function collectMetadataMarkers(sourceFile) {
+  const facts = [];
+  const addMarker = (name) => {
+    if (name === "generateMetadata") facts.push("generatemetadata");
+    if (name === "getServerSideProps") facts.push("getserversideprops");
+    if (name === "getStaticProps") facts.push("getstaticprops");
+    if (name === "getStaticPaths") facts.push("getstaticpaths");
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts4.isFunctionDeclaration(statement) && statement.name) {
+      addMarker(statement.name.text);
+      continue;
+    }
+    if (ts4.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts4.isIdentifier(declaration.name)) addMarker(declaration.name.text);
+      }
+    }
+  }
+  return [...new Set(facts)];
+}
+function collectRouteMethods(sourceFile) {
+  const methods = /* @__PURE__ */ new Set();
+  const addFromDeclaration = (name) => {
+    if (!name) return;
+    const normalized = name.toUpperCase();
+    if (ROUTE_METHODS.has(normalized)) methods.add(normalized.toLowerCase());
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts4.isFunctionDeclaration(statement) && statement.name) {
+      addFromDeclaration(statement.name.text);
+      continue;
+    }
+    if (!ts4.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts4.isIdentifier(declaration.name)) continue;
+      if (isFunctionLikeExpression(declaration.initializer)) {
+        addFromDeclaration(declaration.name.text);
+      }
+    }
+  }
+  return [...methods].join(",");
+}
+function isFunctionLikeExpression(node) {
+  return node !== void 0 && (ts4.isArrowFunction(node) || ts4.isFunctionExpression(node));
+}
+function runtimeFromSource(sourceFile) {
+  if (hasDirective(sourceFile, "use client")) return "client";
+  if (hasDirective(sourceFile, "use server")) return "server";
+  return "server";
+}
+function hasDirective(sourceFile, directive) {
+  return sourceFile.statements.slice(0, 8).some(
+    (statement) => ts4.isExpressionStatement(statement) && ts4.isStringLiteral(statement.expression) && statement.expression.text === directive
+  );
+}
+function collectContainingAppLayouts(relativePath, context) {
+  const fileSegments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (fileSegments[0] !== "app") return [];
+  const layoutSegments = fileSegments.slice(1, -1);
+  const candidates = [];
+  for (let index = 0; index <= layoutSegments.length; index += 1) {
+    const prefix = layoutSegments.slice(0, index);
+    const candidateWithoutExt = ["app", ...prefix, "layout"].join("/");
+    const tsx = `${candidateWithoutExt}.tsx`;
+    const ts9 = `${candidateWithoutExt}.ts`;
+    if (programContainsSourceFile(context, tsx)) candidates.push(tsx);
+    if (programContainsSourceFile(context, ts9)) candidates.push(ts9);
+  }
+  return candidates;
+}
+function programContainsSourceFile(context, candidateRelative) {
+  const absolute = path5.resolve(context.root, candidateRelative);
+  return context.program.getSourceFiles().some((source) => normalizeSourcePath(source.fileName) === normalizeSourcePath(absolute));
+}
+function normalizeSourcePath(value) {
+  return value.replace(/\\/g, "/");
+}
+function isDynamicSegment(segment) {
+  return /^\[{1,2}\.?.*\]$/.test(segment);
+}
+function dynamicSegmentNames(segments) {
+  return segments.filter(isDynamicSegment).map(stripDynamicMarkers);
+}
+function stripDynamicMarkers(segment) {
+  return segment.replace(/^\[\[?\.*/g, "").replace(/\]$/g, "");
+}
+function buildRouteFromSegments(segments) {
+  const cleaned = segments.filter(Boolean).filter((segment) => !ROUTE_GROUP_SEGMENT.test(segment)).map((segment) => segment);
+  return `/${cleaned.length > 0 ? cleaned.join("/") : ""}`;
+}
+function makeRelation2(from, type, to, context, node, confidence, explanation) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    from,
+    type,
+    to,
+    confidence,
+    origin: {
+      file: context.relativePath,
+      line: nodeLine(context.sourceFile, node),
+      range: nodeRange(context.sourceFile, node),
+      explanation,
+      classification: confidence === 1 ? "framework-derived" : "heuristic",
+      analyzer: "nextjs"
+    }
+  };
+}
+
+// src/analyzers/react.ts
+import path6 from "path";
+import ts5 from "typescript";
+var REACT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var REACT_BUILTIN_HOOKS = /* @__PURE__ */ new Set([
+  "useState",
+  "useReducer",
+  "useMemo",
+  "useCallback",
+  "useEffect",
+  "useLayoutEffect",
+  "useContext"
+]);
+var REACT_FACTORYS = /* @__PURE__ */ new Set(["memo", "forwardRef"]);
+var ReactAnalyzer = class {
+  name = "react";
+  version = ANALYZER_VERSION;
+  supports(context) {
+    const extension = path6.extname(context.relativePath).toLowerCase();
+    if (!REACT_EXTENSIONS.has(extension)) return false;
+    return hasDirective2(context.sourceFile, "use client") || hasDirective2(context.sourceFile, "use server") || hasReactImport(context.sourceFile) || hasAnyJsx(context.sourceFile);
+  }
+  analyze(context) {
+    const profile = collectImportProfile(context.sourceFile);
+    const symbols = [];
+    const relations = [];
+    const componentIds = /* @__PURE__ */ new Map();
+    const hookIds = /* @__PURE__ */ new Map();
+    const components = [];
+    for (const statement of context.sourceFile.statements) {
+      if (ts5.isFunctionDeclaration(statement) && statement.name) {
+        const name = statement.name.text;
+        if (isCustomHookName(name) && statement.body) {
+          const symbol = makeSymbol(context, statement, "react-hook", {
+            name,
+            exported: isNameExported2(context.sourceFile, statement),
+            defaultExport: hasDefaultModifier(statement),
+            facts: { runtime: inferRuntime(context.sourceFile) }
+          });
+          symbols.push(symbol);
+          hookIds.set(name.toLowerCase(), symbol.id);
+          continue;
+        }
+        if (statement.body && isComponentName(name, statement.body)) {
+          const facts = collectComponentFacts(
+            context,
+            name,
+            statement.parameters,
+            statement.body,
+            profile
+          );
+          const symbol = makeSymbol(context, statement, "react-component", {
+            name,
+            exported: isNameExported2(context.sourceFile, statement),
+            defaultExport: hasDefaultModifier(statement),
+            facts
+          });
+          symbols.push(symbol);
+          componentIds.set(name.toLowerCase(), symbol.id);
+          components.push({ name, id: symbol.id, body: statement.body });
+          continue;
+        }
+      }
+      if (ts5.isVariableStatement(statement)) {
+        const exported = isNameExported2(context.sourceFile, statement);
+        const defaultExport = hasDefaultModifier(statement);
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts5.isIdentifier(declaration.name) || !declaration.initializer) continue;
+          const name = declaration.name.text;
+          if (isContextFactory(declaration.initializer, profile)) {
+            symbols.push(
+              makeSymbol(context, declaration, "react-context", {
+                name,
+                exported,
+                defaultExport,
+                facts: { runtime: inferRuntime(context.sourceFile), type: "react-context" }
+              })
+            );
+            continue;
+          }
+          if (isCustomHookName(name) && isFunctionLikeExpression2(declaration.initializer)) {
+            const body = functionBody(declaration.initializer);
+            if (body) {
+              const symbol2 = makeSymbol(context, declaration, "react-hook", {
+                name,
+                exported,
+                defaultExport,
+                facts: { runtime: inferRuntime(context.sourceFile) }
+              });
+              symbols.push(symbol2);
+              hookIds.set(name.toLowerCase(), symbol2.id);
+            }
+            continue;
+          }
+          const extracted = extractComponentFromExpression(declaration.initializer, name, profile);
+          if (!extracted) continue;
+          const facts = collectComponentFacts(
+            context,
+            name,
+            extracted.parameters,
+            extracted.body,
+            profile
+          );
+          const symbol = makeSymbol(context, declaration, "react-component", {
+            name,
+            exported,
+            defaultExport,
+            facts
+          });
+          symbols.push(symbol);
+          componentIds.set(name.toLowerCase(), symbol.id);
+          components.push({ name, id: symbol.id, body: extracted.body });
+        }
+      }
+      if (ts5.isClassDeclaration(statement) && statement.name && isReactClassComponent(statement)) {
+        const name = statement.name.text;
+        const renderMethod = statement.members.find(
+          (member) => ts5.isMethodDeclaration(member) && ts5.isIdentifier(member.name) && member.name.text === "render" && Boolean(member.body)
+        );
+        if (!renderMethod?.body) continue;
+        const symbol = makeSymbol(context, statement, "react-component", {
+          name,
+          exported: isNameExported2(context.sourceFile, statement),
+          defaultExport: hasDefaultModifier(statement),
+          facts: { runtime: inferRuntime(context.sourceFile), class: true }
+        });
+        symbols.push(symbol);
+        componentIds.set(name.toLowerCase(), symbol.id);
+        components.push({ name, id: symbol.id, body: renderMethod.body });
+      }
+    }
+    for (const component of components) {
+      const rendered = collectRenderedComponents(component.body);
+      for (const candidate of rendered) {
+        const to = componentIds.get(candidate.name.toLowerCase()) ?? resolveReactCandidateWithChecker(context, candidate, "react-component") ?? resolveImportedReactComponent(context, profile, candidate.name) ?? symbolId("react-component", context.relativePath, candidate.name);
+        relations.push(
+          makeRelation3(component.id, "renders", to, context, candidate.node, 0.95, "JSX render")
+        );
+      }
+      for (const candidate of collectCalledCustomHooks(component.body, profile)) {
+        const to = hookIds.get(candidate.name.toLowerCase()) ?? resolveReactCandidateWithChecker(context, candidate, "react-hook") ?? resolveImportedReactSymbol(context, profile, candidate.name, "react-hook") ?? symbolId("react-hook", context.relativePath, candidate.name);
+        relations.push(
+          makeRelation3(
+            component.id,
+            "uses-hook",
+            to,
+            context,
+            candidate.node,
+            0.95,
+            "custom hook call"
+          )
+        );
+      }
+    }
+    return { symbols, relations, frameworks: ["react"] };
+  }
+};
+function hasReactImport(sourceFile) {
+  return sourceFile.statements.some(
+    (statement) => ts5.isImportDeclaration(statement) && ts5.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "react"
+  );
+}
+function hasDirective2(sourceFile, value) {
+  return sourceFile.statements.slice(0, 8).some(
+    (statement) => ts5.isExpressionStatement(statement) && ts5.isStringLiteral(statement.expression) && statement.expression.text === value
+  );
+}
+function hasAnyJsx(sourceFile) {
+  let found = false;
+  visit2(sourceFile, (node) => {
+    if (found) return;
+    if (ts5.isJsxElement(node) || ts5.isJsxSelfClosingElement(node) || ts5.isJsxOpeningElement(node) || ts5.isJsxFragment(node)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function inferRuntime(sourceFile) {
+  if (hasDirective2(sourceFile, "use client")) return "client";
+  if (hasDirective2(sourceFile, "use server")) return "server";
+  return "unclassified";
+}
+function isNameExported2(sourceFile, node) {
+  return hasExportModifier(node);
+}
+function collectImportProfile(sourceFile) {
+  const hookAliases = /* @__PURE__ */ new Map();
+  const namespaceAliases = /* @__PURE__ */ new Set();
+  const localImports = /* @__PURE__ */ new Map();
+  for (const statement of sourceFile.statements) {
+    if (!ts5.isImportDeclaration(statement) || !ts5.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const source = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (!clause) continue;
+    if (source === "react") {
+      if (clause.name) {
+        hookAliases.set(clause.name.text, clause.name.text);
+        localImports.set(clause.name.text, { source, imported: "default" });
+      }
+      if (!clause.namedBindings) continue;
+      if (ts5.isNamespaceImport(clause.namedBindings)) {
+        namespaceAliases.add(clause.namedBindings.name.text);
+        continue;
+      }
+      for (const item of clause.namedBindings.elements) {
+        const local = item.name.text;
+        const imported = item.propertyName?.text ?? item.name.text;
+        hookAliases.set(local, imported);
+        localImports.set(local, { source, imported });
+      }
+      continue;
+    }
+    if (clause.name) {
+      localImports.set(clause.name.text, { source, imported: "default" });
+    }
+    if (!clause.namedBindings) continue;
+    if (ts5.isNamedImports(clause.namedBindings)) {
+      for (const item of clause.namedBindings.elements) {
+        localImports.set(item.name.text, {
+          source,
+          imported: item.propertyName?.text ?? item.name.text
+        });
+      }
+    } else if (ts5.isNamespaceImport(clause.namedBindings)) {
+      localImports.set(clause.namedBindings.name.text, {
+        source,
+        imported: "*"
+      });
+    }
+  }
+  return { hookAliases, namespaceAliases, localImports };
+}
+function isCustomHookName(name) {
+  return /^use[A-Z]/.test(name);
+}
+function isComponentName(name, body) {
+  return Boolean(body && isUpperCase(name) && !isCustomHookName(name) && containsJsx(body));
+}
+function isUpperCase(name) {
+  return /^[A-Z]/.test(name);
+}
+function isContextFactory(value, profile) {
+  return ts5.isCallExpression(value) && resolveCallName(value.expression, profile) === "createContext";
+}
+function extractComponentFromExpression(value, name, profile) {
+  if (!isUpperCase(name) || isCustomHookName(name)) return void 0;
+  if (isFunctionLikeExpression2(value)) {
+    return { body: value.body, parameters: value.parameters };
+  }
+  if (ts5.isClassExpression(value)) {
+    const renderMethod = value.members.find(
+      (member) => ts5.isMethodDeclaration(member) && ts5.isIdentifier(member.name) && member.name.text === "render" && Boolean(member.body)
+    );
+    if (!renderMethod?.body) return void 0;
+    return { body: renderMethod.body, parameters: renderMethod.parameters };
+  }
+  if (ts5.isCallExpression(value)) {
+    const calledName = resolveCallName(value.expression, profile);
+    if (!calledName || !REACT_FACTORYS.has(calledName) || value.arguments.length === 0)
+      return void 0;
+    const first = value.arguments[0];
+    if (!ts5.isFunctionLike(first) || !containsJsx(first.body)) return void 0;
+    return { body: first.body, parameters: first.parameters };
+  }
+  return void 0;
+}
+function isFunctionLikeExpression2(expression) {
+  return ts5.isArrowFunction(expression) || ts5.isFunctionExpression(expression);
+}
+function isReactClassComponent(statement) {
+  if (!statement.heritageClauses) return false;
+  return statement.heritageClauses.some(
+    (clause) => clause.types.some((item) => {
+      const expr = item.expression;
+      const typeName = ts5.isIdentifier(expr) ? expr.text : ts5.isPropertyAccessExpression(expr) ? expr.name.text : void 0;
+      return typeName === "Component" || typeName === "PureComponent";
+    })
+  );
+}
+function functionBody(expression) {
+  return isFunctionLikeExpression2(expression) ? expression.body : void 0;
+}
+function collectComponentFacts(context, name, parameters, body, profile) {
+  const facts = {
+    runtime: inferRuntime(context.sourceFile)
+  };
+  const props = collectProps(context, parameters[0]);
+  if (props.length > 0) {
+    facts.props = `${name.toLowerCase()}props:${props.join(",")}`;
+  }
+  const behavior = collectComponentBehavior(context, body, profile);
+  if (behavior.state.length > 0) facts.state = behavior.state.join(",");
+  if (behavior.memo.length > 0) facts.memo = behavior.memo.join(",");
+  if (behavior.effects.length > 0) facts.effects = behavior.effects.join(",");
+  if (behavior.customHooks.length > 0) facts.hooks = behavior.customHooks.join(",");
+  return facts;
+}
+function collectProps(context, parameter) {
+  if (!parameter) return [];
+  const values = [];
+  collectBindingNames(parameter.name, values);
+  if (parameter.type) {
+    values.push(...collectInterfaceMembers(parameter.type, context));
+  }
+  return dedupe2(values);
+}
+function collectComponentBehavior(context, body, profile) {
+  const state = [];
+  const memo = [];
+  const effects = [];
+  const customHooks = [];
+  visit2(body, (node) => {
+    if (!ts5.isCallExpression(node)) return;
+    const called = resolveCallName(node.expression, profile);
+    if (!called) return;
+    const declaration = variableDeclarationOfCall(node);
+    if (called === "useState" || called === "useReducer") {
+      if (declaration?.name) {
+        const declaredNames = [];
+        collectBindingNames(declaration.name, declaredNames);
+        state.push(...declaredNames);
+      }
+      if (called === "useReducer") state.push("reducer");
+      return;
+    }
+    if (called === "useMemo" || called === "useCallback") {
+      const target = declaration?.name && ts5.isIdentifier(declaration.name) ? declaration.name.text : called;
+      const dependencies = dependencyText(node.arguments[1], context.sourceFile);
+      memo.push(`${called.toLowerCase()}:${target.toLowerCase()}<-${dependencies}`);
+      return;
+    }
+    if (called === "useEffect" || called === "useLayoutEffect") {
+      const deps = node.arguments[1] ? compactText(redactStringLiterals(node.arguments[1].getText(context.sourceFile))) : "[]";
+      effects.push(`useeffect:${deps}`);
+      return;
+    }
+    if (called.startsWith("use") && !REACT_BUILTIN_HOOKS.has(called)) {
+      customHooks.push(called.toLowerCase());
+    }
+  });
+  return {
+    state: dedupe2(state),
+    memo: dedupe2(memo),
+    effects: dedupe2(effects),
+    customHooks: dedupe2(customHooks)
+  };
+}
+function collectCalledCustomHooks(node, profile) {
+  const hooks = [];
+  visit2(node, (current) => {
+    if (!ts5.isCallExpression(current)) return;
+    const called = resolveCallName(current.expression, profile);
+    if (called && called.startsWith("use") && !REACT_BUILTIN_HOOKS.has(called)) {
+      hooks.push({ name: called, node: current });
+    }
+  });
+  return hooks;
+}
+function collectRenderedComponents(node) {
+  const components = [];
+  visit2(node, (current) => {
+    if (!ts5.isJsxElement(current) && !ts5.isJsxSelfClosingElement(current)) return;
+    const evidenceNode = ts5.isJsxElement(current) ? current.openingElement : current;
+    const tag = jsxTagName(evidenceNode.tagName);
+    if (tag && isUpperCase(tag)) {
+      components.push({ name: tag, node: evidenceNode });
+    }
+  });
+  return components;
+}
+function resolveImportedReactComponent(context, profile, renderedName) {
+  return resolveImportedReactSymbol(context, profile, renderedName, "react-component");
+}
+function resolveReactCandidateWithChecker(context, candidate, kind) {
+  let location = candidate.node;
+  if (ts5.isJsxOpeningElement(candidate.node) || ts5.isJsxSelfClosingElement(candidate.node)) {
+    location = candidate.node.tagName;
+  } else if (ts5.isCallExpression(candidate.node)) {
+    location = candidate.node.expression;
+  }
+  let symbol = context.checker.getSymbolAtLocation(location);
+  if (!symbol && ts5.isPropertyAccessExpression(location)) {
+    symbol = context.checker.getSymbolAtLocation(location.name);
+  }
+  if (!symbol) return void 0;
+  if (symbol.flags & ts5.SymbolFlags.Alias) {
+    try {
+      symbol = context.checker.getAliasedSymbol(symbol);
+    } catch {
+      return void 0;
+    }
+  }
+  const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  if (!declaration) return void 0;
+  const sourceFile = declaration.getSourceFile();
+  let relative;
+  try {
+    relative = path6.relative(context.root, sourceFile.fileName).split(path6.sep).join("/");
+  } catch {
+    return void 0;
+  }
+  if (relative === "" || relative === ".." || relative.startsWith("../") || path6.isAbsolute(relative) || context.indexedSourcePaths && !context.indexedSourcePaths.has(relative)) {
+    return void 0;
+  }
+  return symbolId(kind, relative, declarationToSymbolName(declaration) ?? symbol.getName());
+}
+function resolveImportedReactSymbol(context, profile, importedName, kind) {
+  const source = profile.localImports.get(importedName);
+  if (!source) return void 0;
+  if (!source.source.startsWith("./") && !source.source.startsWith("../")) {
+    const resolved = context.resolveModule?.(source.source, context.sourceFile.fileName);
+    if (!resolved) return void 0;
+    if (!isPathInside(context.root, resolved.resolvedFileName)) return void 0;
+    const relative2 = relativePosix(context.root, resolved.resolvedFileName);
+    if (context.indexedSourcePaths && !context.indexedSourcePaths.has(relative2)) return void 0;
+    const sourceFile = context.program.getSourceFile(resolved.resolvedFileName);
+    const declaration = sourceFile ? findExportedDeclaration2(sourceFile, source.imported) : void 0;
+    const actualName = declaration ? declarationToSymbolName(declaration) : void 0;
+    if (actualName) return symbolId(kind, relative2, actualName);
+    return symbolId(kind, relative2, source.imported);
+  }
+  const relative = path6.posix.normalize(
+    path6.posix.join(path6.posix.dirname(context.relativePath), source.source)
+  );
+  const candidates = [
+    relative,
+    `${relative}.ts`,
+    `${relative}.tsx`,
+    `${relative}.js`,
+    `${relative}.jsx`,
+    `${relative}.mjs`,
+    `${relative}.cjs`,
+    `${relative}/index.ts`,
+    `${relative}/index.tsx`,
+    `${relative}/index.jsx`
+  ];
+  for (const candidate of candidates) {
+    const absolute = path6.resolve(context.root, candidate);
+    const imported = context.program.getSourceFile(absolute);
+    if (imported) {
+      const declaration = findExportedDeclaration2(imported, source.imported);
+      if (declaration) {
+        const symbolName = declarationToSymbolName(declaration);
+        if (symbolName) return symbolId(kind, candidate, symbolName);
+      }
+      if (source.imported !== "*") return symbolId(kind, candidate, source.imported);
+    }
+  }
+  const fallback = source.imported === "*" ? importedName : source.imported;
+  return symbolId(kind, relative, fallback);
+}
+function declarationToSymbolName(declaration) {
+  if (ts5.isFunctionDeclaration(declaration)) return declaration.name?.text ?? "default";
+  if (ts5.isClassDeclaration(declaration)) return declaration.name?.text ?? "default";
+  if (ts5.isInterfaceDeclaration(declaration) || ts5.isTypeAliasDeclaration(declaration))
+    return declaration.name.text;
+  if (ts5.isVariableDeclaration(declaration) && ts5.isIdentifier(declaration.name))
+    return declaration.name.text;
+  return "default";
+}
+function findExportedDeclaration2(sourceFile, exportedName) {
+  for (const statement of sourceFile.statements) {
+    if (ts5.isFunctionDeclaration(statement) && (exportedName === "default" && hasDefaultModifier(statement) || statement.name?.text === exportedName))
+      return statement;
+    if (ts5.isClassDeclaration(statement) && (exportedName === "default" && hasDefaultModifier(statement) || statement.name?.text === exportedName))
+      return statement;
+    if (ts5.isInterfaceDeclaration(statement) && (exportedName === "default" && hasDefaultModifier(statement) || statement.name.text === exportedName))
+      return statement;
+    if (ts5.isTypeAliasDeclaration(statement) && (exportedName === "default" && hasDefaultModifier(statement) || statement.name.text === exportedName))
+      return statement;
+    if (ts5.isVariableStatement(statement)) {
+      const declaration = exportedName === "default" ? statement.declarationList.declarations.find(
+        (item) => hasDefaultModifier(statement) && ts5.isIdentifier(item.name)
+      ) : statement.declarationList.declarations.find(
+        (item) => ts5.isIdentifier(item.name) && item.name.text === exportedName
+      );
+      if (declaration && ts5.isIdentifier(declaration.name)) return declaration;
+    }
+    if (ts5.isExportDeclaration(statement) && statement.exportClause && ts5.isNamedExports(statement.exportClause)) {
+      const specifier = statement.exportClause.elements.find(
+        (item) => item.name.text === exportedName || item.name.text === "default" && item.propertyName?.text === exportedName
+      );
+      if (!specifier) continue;
+      return findExportedDeclaration2(
+        sourceFile,
+        specifier.propertyName?.text ?? specifier.name.text
+      );
+    }
+    if (ts5.isExportAssignment(statement) && !statement.isExportEquals && ts5.isIdentifier(statement.expression)) {
+      return findDeclarationByName2(sourceFile, statement.expression.text);
+    }
+  }
+  return void 0;
+}
+function findDeclarationByName2(sourceFile, name) {
+  for (const statement of sourceFile.statements) {
+    if (ts5.isFunctionDeclaration(statement) || ts5.isClassDeclaration(statement) || ts5.isInterfaceDeclaration(statement) || ts5.isTypeAliasDeclaration(statement)) {
+      if (statement.name?.text === name) return statement;
+    }
+    if (ts5.isVariableStatement(statement)) {
+      const declaration = statement.declarationList.declarations.find(
+        (item) => ts5.isIdentifier(item.name) && item.name.text === name
+      );
+      if (declaration) return declaration;
+    }
+  }
+  return void 0;
+}
+function dependencyText(expression, sourceFile) {
+  if (!expression || !ts5.isArrayLiteralExpression(expression)) return "[]";
+  return expression.elements.map((element) => compactText(redactStringLiterals(element.getText(sourceFile)))).join(",");
+}
+function resolveCallName(expression, profile) {
+  if (ts5.isIdentifier(expression)) {
+    return profile.hookAliases.get(expression.text) ?? expression.text;
+  }
+  if (ts5.isPropertyAccessExpression(expression) && ts5.isIdentifier(expression.expression) && profile.namespaceAliases.has(expression.expression.text)) {
+    return expression.name.text;
+  }
+  return void 0;
+}
+function variableDeclarationOfCall(node) {
+  let current = node.parent;
+  while (current) {
+    if (ts5.isVariableDeclaration(current)) return current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function collectBindingNames(name, values) {
+  if (ts5.isIdentifier(name)) {
+    values.push(name.text.toLowerCase());
+    return;
+  }
+  if (ts5.isObjectBindingPattern(name) || ts5.isArrayBindingPattern(name)) {
+    for (const element of name.elements) {
+      if (ts5.isBindingElement(element)) collectBindingNames(element.name, values);
+    }
+  }
+}
+function collectInterfaceMembers(typeNode, context) {
+  if (ts5.isTypeLiteralNode(typeNode)) {
+    return typeNode.members.flatMap((member) => {
+      const name = propertyNameText(member.name);
+      return name ? [name.toLowerCase()] : [];
+    });
+  }
+  if (ts5.isTypeReferenceNode(typeNode) && ts5.isIdentifier(typeNode.typeName)) {
+    const symbol = context.checker.getSymbolAtLocation(typeNode.typeName);
+    const resolved = symbol && symbol.flags & ts5.SymbolFlags.Alias ? context.checker.getAliasedSymbol(symbol) : symbol;
+    const declaration = resolved?.declarations?.[0];
+    if (declaration && ts5.isInterfaceDeclaration(declaration)) {
+      return declaration.members.flatMap((member) => {
+        const name = propertyNameText(member.name);
+        return name ? [name.toLowerCase()] : [];
+      });
+    }
+  }
+  return [];
+}
+function containsJsx(node) {
+  let found = false;
+  visit2(node, (current) => {
+    if (ts5.isJsxElement(current) || ts5.isJsxSelfClosingElement(current) || ts5.isJsxOpeningElement(current) || ts5.isJsxFragment(current)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function jsxTagName(tag) {
+  if (ts5.isIdentifier(tag) || ts5.isStringLiteral(tag)) return tag.text;
+  if (ts5.isPropertyAccessExpression(tag)) return tag.name.text;
+  return void 0;
+}
+function visit2(node, callback) {
+  callback(node);
+  ts5.forEachChild(node, (child) => visit2(child, callback));
+}
+function dedupe2(values) {
+  return [...new Set(values)];
+}
+function makeRelation3(from, type, to, context, node, confidence, explanation) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    from,
+    type,
+    to,
+    confidence,
+    origin: {
+      file: context.relativePath,
+      line: nodeLine(context.sourceFile, node),
+      range: nodeRange(context.sourceFile, node),
+      explanation,
+      classification: "framework-derived",
+      analyzer: "react"
+    }
+  };
+}
+
+// src/compiler-units.ts
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from "fs";
+import path7 from "path";
+import fg from "fast-glob";
+import ts6 from "typescript";
+var FALLBACK_UNIT_ID = generatedCompilerUnitId("fallback");
+function sanitizeCompilerPathAliases(options) {
+  if (!options.paths) return;
+  const sanitized = {};
+  for (const [alias, targets] of Object.entries(options.paths).sort(
+    ([a], [b]) => compareText(a, b)
+  )) {
+    if (!isSafeRelativePathPattern(alias)) continue;
+    const safeTargets = targets.filter(isSafeRelativePathPattern);
+    if (safeTargets.length > 0) sanitized[alias] = safeTargets;
+  }
+  options.paths = sanitized;
+}
+function boundedTypeRoots(root, start) {
+  const values = [];
+  let current = path7.resolve(start);
+  while (isPathInside(root, current)) {
+    values.push(path7.join(current, "node_modules", "@types"));
+    if (current === path7.resolve(root)) break;
+    const parent = path7.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return [...new Set(values)];
+}
+var BoundedTypeScriptFileSystem = class {
+  extendedConfigCache = /* @__PURE__ */ new Map();
+  root;
+  typeScriptLib;
+  observedInputs = /* @__PURE__ */ new Map();
+  constructor(root) {
+    this.root = realpathSync(root);
+    this.typeScriptLib = realpathSync(path7.dirname(ts6.getDefaultLibFilePath({})));
+  }
+  fileExists = (fileName) => {
+    const absolute = this.absolute(fileName);
+    if (!this.isPermitted(absolute)) return false;
+    try {
+      const exists = statSync(absolute).isFile();
+      this.recordProbe(absolute, "file", exists);
+      return exists;
+    } catch {
+      this.recordProbe(absolute, "file", false);
+      return false;
+    }
+  };
+  readFile = (fileName) => {
+    const absolute = this.absolute(fileName);
+    if (!this.isPermitted(absolute)) return void 0;
+    try {
+      const contents = readFileSync(absolute);
+      this.recordRead(absolute, contents);
+      return contents.toString("utf8");
+    } catch {
+      let exists = false;
+      try {
+        exists = statSync(absolute).isFile();
+      } catch {
+      }
+      this.recordProbe(absolute, "file", exists);
+      this.recordProbe(absolute, "readable-file", false);
+      return void 0;
+    }
+  };
+  directoryExists = (directory) => {
+    const absolute = this.absolute(directory);
+    if (!this.isPermitted(absolute)) return false;
+    try {
+      const exists = statSync(absolute).isDirectory();
+      this.recordProbe(absolute, "directory", exists);
+      return exists;
+    } catch {
+      this.recordProbe(absolute, "directory", false);
+      return false;
+    }
+  };
+  getDirectories = (directory) => {
+    const absolute = this.absolute(directory);
+    if (!this.isPermitted(absolute)) return [];
+    if (!this.directoryExists(absolute)) return [];
+    const directories = ts6.sys.getDirectories(absolute).filter((entry) => this.isPermitted(path7.resolve(absolute, entry))).sort(compareText);
+    this.recordDirectoryListing(absolute, directories);
+    return directories;
+  };
+  readDirectory = (rootDir, extensions, excludes, includes, depth) => {
+    const absolute = this.absolute(rootDir);
+    if (!this.isPermitted(absolute)) return [];
+    return ts6.sys.readDirectory(absolute, extensions, excludes, includes, depth).filter((entry) => this.isPermitted(path7.resolve(absolute, entry))).sort(compareText);
+  };
+  realpath = (candidate) => {
+    const absolute = this.absolute(candidate);
+    if (!this.isPermitted(absolute)) return absolute;
+    try {
+      const real = realpathSync(absolute);
+      this.recordSymlink(absolute, real);
+      return real;
+    } catch {
+      return absolute;
+    }
+  };
+  parseHost(currentDirectory) {
+    return {
+      useCaseSensitiveFileNames: ts6.sys.useCaseSensitiveFileNames,
+      getCurrentDirectory: () => currentDirectory,
+      fileExists: this.fileExists,
+      readFile: this.readFile,
+      readDirectory: this.readDirectory,
+      directoryExists: this.directoryExists,
+      getDirectories: this.getDirectories,
+      realpath: this.realpath,
+      onUnRecoverableConfigFileDiagnostic: () => void 0
+    };
+  }
+  semanticInputs() {
+    return [...this.observedInputs.values()].sort(
+      (a, b) => compareText(semanticObservationKey(a), semanticObservationKey(b))
+    );
+  }
+  recordProbe(absolute, targetKind, exists) {
+    const scoped = this.semanticScope(absolute);
+    if (!scoped) return;
+    const relative = relativePosix(scoped.root, absolute);
+    const contentKey = targetKind === "directory" ? `directory-listing\0${scoped.scope}\0${relative}` : scoped.scope === "toolchain" ? `toolchain-file\0${relative}` : `file\0${relative}`;
+    if (this.observedInputs.has(contentKey)) return;
+    const observation = {
+      path: relative,
+      kind: "resolution-probe",
+      scope: scoped.scope,
+      targetKind,
+      exists
+    };
+    this.observedInputs.set(semanticObservationKey(observation), observation);
+  }
+  recordRead(absolute, contents) {
+    if (isPathInside(this.root, absolute)) {
+      const relative = relativePosix(this.root, absolute);
+      this.observedInputs.delete(`resolution-probe\0project\0file\0${relative}`);
+      this.observedInputs.delete(
+        `resolution-probe\0project\0readable-file\0${relative}`
+      );
+      const observation = {
+        path: relative,
+        kind: "file",
+        hash: hashText(contents)
+      };
+      this.observedInputs.set(semanticObservationKey(observation), observation);
+      return;
+    }
+    if (isPathInside(this.typeScriptLib, absolute)) {
+      const relative = relativePosix(this.typeScriptLib, absolute);
+      this.observedInputs.delete(`resolution-probe\0toolchain\0file\0${relative}`);
+      this.observedInputs.delete(
+        `resolution-probe\0toolchain\0readable-file\0${relative}`
+      );
+      const observation = {
+        // Preserve the lexical file TypeScript opened. Hashing only a resolved target would miss
+        // a same-version standard-library symlink being repointed to different bytes.
+        path: relative,
+        kind: "toolchain-file",
+        hash: hashText(contents)
+      };
+      this.observedInputs.set(semanticObservationKey(observation), observation);
+    }
+  }
+  recordDirectoryListing(absolute, entries) {
+    const scoped = this.semanticScope(absolute);
+    if (!scoped) return;
+    const relative = relativePosix(scoped.root, absolute);
+    this.observedInputs.delete(
+      `resolution-probe\0${scoped.scope}\0directory\0${relative}`
+    );
+    const observation = {
+      path: relative,
+      kind: "directory-listing",
+      scope: scoped.scope,
+      hash: semanticDirectoryListingHash(absolute, entries)
+    };
+    this.observedInputs.set(semanticObservationKey(observation), observation);
+  }
+  recordSymlink(absolute, real) {
+    const scoped = this.semanticScope(absolute);
+    if (!scoped) return;
+    const relative = relativePosix(scoped.root, absolute);
+    const target = isPathInside(scoped.root, real) ? relativePosix(scoped.root, real) : "<outside-root>";
+    if (relative === target) return;
+    const observation = {
+      path: relative,
+      kind: "symlink",
+      scope: scoped.scope,
+      target
+    };
+    this.observedInputs.set(semanticObservationKey(observation), observation);
+  }
+  semanticScope(absolute) {
+    if (isPathInside(this.root, absolute)) return { scope: "project", root: this.root };
+    if (isPathInside(this.typeScriptLib, absolute)) {
+      return { scope: "toolchain", root: this.typeScriptLib };
+    }
+    return void 0;
+  }
+  isPermitted(candidate) {
+    const absolute = this.absolute(candidate);
+    const lexicalInRoot = isPathInside(this.root, absolute);
+    const lexicalInToolchain = isPathInside(this.typeScriptLib, absolute);
+    const lexicalAllowed = lexicalInRoot || lexicalInToolchain;
+    if (!lexicalAllowed) return false;
+    if (!existsSync(absolute)) return true;
+    try {
+      const real = realpathSync(absolute);
+      this.recordSymlink(absolute, real);
+      return lexicalInRoot && isPathInside(this.root, real) || lexicalInToolchain && isPathInside(this.typeScriptLib, real);
+    } catch {
+      return false;
+    }
+  }
+  absolute(candidate) {
+    return path7.isAbsolute(candidate) ? path7.resolve(candidate) : path7.resolve(this.root, candidate);
+  }
+};
+function semanticDirectoryListingHash(directory, entries) {
+  const normalized = entries.map((entry) => normalizeStoredPath(path7.relative(directory, path7.resolve(directory, entry)))).sort(compareText);
+  return hashText(Buffer.from(normalized.join("\0"), "utf8"));
+}
+function semanticObservationKey(observation) {
+  return observation.kind === "resolution-probe" ? `${observation.kind}\0${observation.scope ?? "project"}\0${observation.targetKind}\0${observation.path}` : observation.kind === "directory-listing" || observation.kind === "symlink" ? `${observation.kind}\0${observation.scope ?? "project"}\0${observation.path}` : `${observation.kind}\0${observation.path}`;
+}
+function fallbackCompilerOptions(root) {
+  return {
+    target: ts6.ScriptTarget.ES2022,
+    module: ts6.ModuleKind.NodeNext,
+    moduleResolution: ts6.ModuleResolutionKind.NodeNext,
+    allowJs: true,
+    checkJs: false,
+    noEmit: true,
+    skipLibCheck: true,
+    jsx: ts6.JsxEmit.Preserve,
+    experimentalDecorators: true,
+    configFilePath: path7.join(root, "tsconfig.fallback.json"),
+    typeRoots: boundedTypeRoots(root, root)
+  };
+}
+
+// src/semantic.ts
+import path8 from "path";
+import ts7 from "typescript";
+var TYPESCRIPT_SEMANTIC_VERSION = `compiler-units-v4+typescript-${ts7.version}`;
+var TypeScriptSemanticResolver = class {
+  constructor(jsDocParsingMode = ts7.JSDocParsingMode.ParseAll) {
+    this.jsDocParsingMode = jsDocParsingMode;
+  }
+  jsDocParsingMode;
+  name = "typescript-program";
+  version = TYPESCRIPT_SEMANTIC_VERSION;
+  resolve(input) {
+    const compiler = loadCompilerConfiguration(input.root, input.tsconfig);
+    const currentDirectory = input.tsconfig ? path8.dirname(path8.resolve(input.root, input.tsconfig)) : input.root;
+    const fileSystem = compiler.fileSystem;
+    const host = createBoundedCompilerHost(
+      input.root,
+      currentDirectory,
+      compiler.options,
+      fileSystem,
+      compiler.parsedCommands
+    );
+    host.jsDocParsingMode = this.jsDocParsingMode;
+    const cache = ts7.createModuleResolutionCache(
+      currentDirectory,
+      (fileName) => host.getCanonicalFileName(fileName),
+      compiler.options
+    );
+    const resolveProjectReferenceModule = createProjectReferenceModuleResolver(
+      input.root,
+      compiler.projectReferences ?? [],
+      fileSystem,
+      compiler.parsedCommands
+    );
+    const resolveModule = (moduleName, containingFile) => {
+      const normal = ts7.resolveModuleName(
+        moduleName,
+        containingFile,
+        compiler.options,
+        host,
+        cache
+      ).resolvedModule;
+      return resolveProjectReferenceModule(moduleName) ?? normal;
+    };
+    host.resolveModuleNameLiterals = (moduleLiterals, containingFile) => moduleLiterals.map((literal) => {
+      const resolvedModule = resolveModule(literal.text, containingFile);
+      return { resolvedModule };
+    });
+    const rootNames = [...new Set(input.sourceFiles.map((file) => path8.resolve(file)))].sort(
+      compareText
+    );
+    const program = ts7.createProgram({
+      rootNames,
+      options: compiler.options,
+      ...compiler.projectReferences?.length ? { projectReferences: compiler.projectReferences } : {},
+      host,
+      // Reference edges are parsed and fingerprinted by the compiler-unit graph. A read-only
+      // scanner resolves their source imports directly so correctness never depends on prebuilt
+      // declaration outputs being present beside a referenced project.
+      configFileParsingDiagnostics: compiler.rawDiagnostics
+    });
+    return {
+      program,
+      checker: program.getTypeChecker(),
+      pathAliases: compiler.pathAliases,
+      diagnostics: compiler.diagnostics,
+      semanticInputs: () => fileSystem.semanticInputs(),
+      resolveModule(moduleName, containingFile) {
+        const resolved = resolveModule(moduleName, containingFile);
+        return resolved ? {
+          resolvedFileName: resolved.resolvedFileName,
+          isExternalLibraryImport: Boolean(resolved.isExternalLibraryImport)
+        } : void 0;
+      }
+    };
+  }
+};
+function createProjectReferenceModuleResolver(root, references, fileSystem, parsedCommands) {
+  const packages = [];
+  for (const reference of references) {
+    const configPath = ts7.resolveProjectReferencePath(reference);
+    if (!isPathInside(root, configPath)) continue;
+    const parsed = parseCommand(root, configPath, fileSystem, parsedCommands);
+    if (!parsed) continue;
+    const packageRoot = path8.dirname(configPath);
+    const packageJsonPath = path8.join(packageRoot, "package.json");
+    const raw = fileSystem.readFile(packageJsonPath);
+    if (!raw) continue;
+    try {
+      const manifest = JSON.parse(raw);
+      if (typeof manifest.name !== "string" || manifest.name.length === 0) continue;
+      packages.push({ name: manifest.name, root: packageRoot, manifest, parsed });
+    } catch {
+    }
+  }
+  packages.sort((a, b) => b.name.length - a.name.length || compareText(a.name, b.name));
+  return (moduleName) => {
+    const referenced = packages.find(
+      (candidate) => moduleName === candidate.name || moduleName.startsWith(`${candidate.name}/`)
+    );
+    if (!referenced) return void 0;
+    const subpath = moduleName === referenced.name ? "" : moduleName.slice(referenced.name.length + 1);
+    const source = referencedPackageSource(referenced, subpath, fileSystem);
+    if (!source) return void 0;
+    return {
+      resolvedFileName: source,
+      extension: moduleExtension(source),
+      isExternalLibraryImport: false
+    };
+  };
+}
+function referencedPackageSource(referenced, subpath, fileSystem) {
+  const { parsed, root: packageRoot, manifest } = referenced;
+  const rootDir = parsed.options.rootDir ?? packageRoot;
+  if (!isPathInside(packageRoot, rootDir)) return void 0;
+  const owned = new Set(parsed.fileNames.map((fileName) => path8.resolve(fileName)));
+  const requestedTargets = packageEntryTargets(manifest, subpath);
+  const bases = [];
+  for (const target of requestedTargets) {
+    const absoluteTarget = path8.resolve(packageRoot, target);
+    if (!isPathInside(packageRoot, absoluteTarget)) continue;
+    const outDir = parsed.options.outDir;
+    if (outDir && isPathInside(outDir, absoluteTarget)) {
+      bases.push(path8.resolve(rootDir, path8.relative(outDir, absoluteTarget)));
+    }
+    bases.push(absoluteTarget);
+  }
+  bases.push(path8.resolve(rootDir, subpath || "index"));
+  for (const base of bases) {
+    for (const candidate of sourceModuleCandidates(base)) {
+      const absolute = path8.resolve(candidate);
+      if (isPathInside(packageRoot, absolute) && owned.has(absolute) && fileSystem.fileExists(absolute)) {
+        return fileSystem.realpath(absolute);
+      }
+    }
+  }
+  const expectedStem = normalizeModuleStem(subpath || "index");
+  const matching = [...owned].filter((fileName) => isPathInside(rootDir, fileName)).filter((fileName) => {
+    const relative = normalizeModuleStem(relativePosix(rootDir, fileName));
+    return relative === expectedStem || relative === `${expectedStem}/index`;
+  }).sort(compareText);
+  return matching[0];
+}
+function packageEntryTargets(manifest, subpath) {
+  const output = [];
+  const exportKey = subpath ? `./${subpath}` : ".";
+  const exportsValue = manifest.exports;
+  if (exportsValue && typeof exportsValue === "object" && !Array.isArray(exportsValue)) {
+    const exportsRecord = exportsValue;
+    const keyed = exportsRecord[exportKey];
+    collectStaticPackageTargets(
+      keyed ?? (!subpath && !("." in exportsRecord) ? exportsValue : void 0),
+      output
+    );
+  } else if (!subpath) {
+    collectStaticPackageTargets(exportsValue, output);
+  }
+  if (!subpath) {
+    for (const field of ["types", "typings", "source", "module", "main"]) {
+      const value = manifest[field];
+      if (typeof value === "string") output.push(value);
+    }
+  }
+  return [...new Set(output)];
+}
+function collectStaticPackageTargets(value, output) {
+  if (typeof value === "string") {
+    output.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectStaticPackageTargets(item, output);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  const record = value;
+  for (const key of ["types", "import", "default", "require", "node"]) {
+    if (key in record) collectStaticPackageTargets(record[key], output);
+  }
+}
+function sourceModuleCandidates(value) {
+  const stem = value.replace(/\.d\.(?:ts|mts|cts)$/i, "").replace(/\.(?:tsx?|mts|cts|jsx?|mjs|cjs)$/i, "");
+  const extensions = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+  return [
+    value,
+    ...extensions.map((extension) => `${stem}${extension}`),
+    ...extensions.map((extension) => path8.join(stem, `index${extension}`))
+  ];
+}
+function normalizeModuleStem(value) {
+  return normalizeStoredPath(value).replace(/\.d\.(?:ts|mts|cts)$/i, "").replace(/\.(?:tsx?|mts|cts|jsx?|mjs|cjs)$/i, "");
+}
+function moduleExtension(fileName) {
+  const lower = fileName.toLowerCase();
+  if (lower.endsWith(".tsx")) return ts7.Extension.Tsx;
+  if (lower.endsWith(".mts")) return ts7.Extension.Mts;
+  if (lower.endsWith(".cts")) return ts7.Extension.Cts;
+  if (lower.endsWith(".jsx")) return ts7.Extension.Jsx;
+  if (lower.endsWith(".mjs")) return ts7.Extension.Mjs;
+  if (lower.endsWith(".cjs")) return ts7.Extension.Cjs;
+  if (lower.endsWith(".js")) return ts7.Extension.Js;
+  return ts7.Extension.Ts;
+}
+function createBoundedModuleResolver(root, currentDirectory, options) {
+  const fileSystem = new BoundedTypeScriptFileSystem(root);
+  const cache = ts7.createModuleResolutionCache(
+    currentDirectory,
+    (fileName) => ts7.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+    options
+  );
+  const host = {
+    fileExists: fileSystem.fileExists,
+    readFile: fileSystem.readFile,
+    directoryExists: fileSystem.directoryExists,
+    getDirectories: fileSystem.getDirectories,
+    realpath: fileSystem.realpath,
+    getCurrentDirectory: () => currentDirectory,
+    useCaseSensitiveFileNames: () => ts7.sys.useCaseSensitiveFileNames
+  };
+  return (moduleName, containingFile) => {
+    const resolved = ts7.resolveModuleName(
+      moduleName,
+      containingFile,
+      options,
+      host,
+      cache
+    ).resolvedModule;
+    return resolved ? {
+      resolvedFileName: resolved.resolvedFileName,
+      isExternalLibraryImport: Boolean(resolved.isExternalLibraryImport)
+    } : void 0;
+  };
+}
+function loadCompilerConfiguration(root, tsconfig) {
+  const fileSystem = new BoundedTypeScriptFileSystem(root);
+  if (!tsconfig) {
+    return {
+      options: fallbackCompilerOptions(root),
+      pathAliases: {},
+      diagnostics: [],
+      rawDiagnostics: [],
+      fileSystem,
+      parsedCommands: /* @__PURE__ */ new Map()
+    };
+  }
+  const absolute = path8.resolve(root, tsconfig);
+  if (!isPathInside(root, absolute) || !fileSystem.fileExists(absolute)) {
+    const diagnostic = {
+      schemaVersion: SCHEMA_VERSION,
+      code: "compiler-config",
+      severity: "warning",
+      message: "The owning TypeScript configuration was unavailable or unsafe; fallback options were used.",
+      ...isPathInside(root, absolute) ? { file: relativePosix(root, absolute) } : {}
+    };
+    return {
+      options: fallbackCompilerOptions(root),
+      pathAliases: {},
+      diagnostics: [diagnostic],
+      rawDiagnostics: [],
+      fileSystem,
+      parsedCommands: /* @__PURE__ */ new Map()
+    };
+  }
+  const parsedCommands = /* @__PURE__ */ new Map();
+  const parsed = parseCommand(root, absolute, fileSystem, parsedCommands);
+  if (!parsed) {
+    return {
+      options: fallbackCompilerOptions(root),
+      pathAliases: {},
+      diagnostics: [
+        {
+          schemaVersion: SCHEMA_VERSION,
+          code: "compiler-config",
+          severity: "warning",
+          message: "The owning TypeScript configuration could not be parsed; fallback options were used.",
+          file: relativePosix(root, absolute)
+        }
+      ],
+      rawDiagnostics: [],
+      fileSystem,
+      parsedCommands
+    };
+  }
+  const projectReferences = (parsed.projectReferences ?? []).filter((reference) => {
+    const target = ts7.resolveProjectReferencePath(reference);
+    return isPathInside(root, target) && fileSystem.fileExists(target);
+  });
+  const options = parsed.options;
+  anchorCompilerOptions(root, path8.dirname(absolute), options);
+  return {
+    options,
+    ...projectReferences.length > 0 ? { projectReferences } : {},
+    pathAliases: pathAliases(root, path8.dirname(absolute), options),
+    diagnostics: parsed.errors.map((diagnostic) => compilerDiagnostic(diagnostic, root)),
+    rawDiagnostics: parsed.errors,
+    fileSystem,
+    parsedCommands
+  };
+}
+function parseCommand(root, configPath, fileSystem, cache) {
+  const absolute = path8.resolve(configPath);
+  const cached = cache.get(absolute);
+  if (cached) return cached;
+  if (!isPathInside(root, absolute) || !fileSystem.fileExists(absolute)) return void 0;
+  try {
+    const source = ts7.readJsonConfigFile(absolute, fileSystem.readFile);
+    const parsed = ts7.parseJsonSourceFileConfigFileContent(
+      source,
+      fileSystem.parseHost(path8.dirname(absolute)),
+      path8.dirname(absolute),
+      void 0,
+      absolute,
+      void 0,
+      void 0,
+      fileSystem.extendedConfigCache
+    );
+    parsed.projectReferences = (parsed.projectReferences ?? []).filter((reference) => {
+      const target = ts7.resolveProjectReferencePath(reference);
+      return isPathInside(root, target) && fileSystem.fileExists(target);
+    });
+    anchorCompilerOptions(root, path8.dirname(absolute), parsed.options);
+    cache.set(absolute, parsed);
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function createBoundedCompilerHost(root, currentDirectory, options, fileSystem, parsedCommands) {
+  const host = ts7.createCompilerHost(options, true);
+  host.getCurrentDirectory = () => currentDirectory;
+  host.fileExists = fileSystem.fileExists;
+  host.readFile = fileSystem.readFile;
+  host.directoryExists = fileSystem.directoryExists;
+  host.getDirectories = fileSystem.getDirectories;
+  host.readDirectory = (rootDir, extensions, excludes, includes, depth) => [
+    ...fileSystem.readDirectory(rootDir, extensions, excludes, includes, depth)
+  ];
+  host.realpath = fileSystem.realpath;
+  host.getEnvironmentVariable = () => "";
+  host.writeFile = () => void 0;
+  host.getParsedCommandLine = (configFileName) => parseCommand(root, configFileName, fileSystem, parsedCommands);
+  host.useSourceOfProjectReferenceRedirect = () => true;
+  return host;
+}
+function anchorCompilerOptions(root, unitDirectory, options) {
+  options.configFilePath = options.configFilePath ?? path8.join(unitDirectory, "tsconfig.json");
+  if (!options.typeRoots) options.typeRoots = boundedTypeRoots2(root, unitDirectory);
+  else options.typeRoots = options.typeRoots.filter((entry) => isPathInside(root, entry));
+  if (options.baseUrl && !isPathInside(root, options.baseUrl)) options.baseUrl = void 0;
+  if (options.rootDirs)
+    options.rootDirs = options.rootDirs.filter((entry) => isPathInside(root, entry));
+  sanitizeCompilerPathAliases(options);
+}
+function boundedTypeRoots2(root, start) {
+  const values = [];
+  let current = path8.resolve(start);
+  while (isPathInside(root, current)) {
+    values.push(path8.join(current, "node_modules", "@types"));
+    if (current === path8.resolve(root)) break;
+    const parent = path8.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return [...new Set(values)];
+}
+function pathAliases(root, configDirectory, options) {
+  const base = options.baseUrl ?? options.pathsBasePath ?? configDirectory;
+  const paths = options.paths ?? {};
+  return Object.fromEntries(
+    Object.entries(paths).filter(([alias]) => isSafeRelativePathPattern(alias)).sort(([a], [b]) => compareText(a, b)).map(([alias, values]) => [
+      alias,
+      values.filter(isSafeRelativePathPattern).map((value) => path8.resolve(base, value)).filter((value) => isPathInside(root, value)).map((value) => normalizeStoredPath(relativePosix(root, value))).filter((value, index, entries) => entries.indexOf(value) === index).sort(compareText)
+    ])
+  );
+}
+function compilerDiagnostic(diagnostic, root) {
+  const message = sanitizeCompilerMessage(
+    ts7.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+    root
+  );
+  const file = diagnostic.file;
+  const start = file && diagnostic.start !== void 0 ? file.getLineAndCharacterOfPosition(diagnostic.start) : void 0;
+  let relativeFile;
+  if (file) {
+    try {
+      relativeFile = relativePosix(root, file.fileName);
+    } catch {
+    }
+  }
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    code: diagnostic.file ? "parse-error" : "compiler-config",
+    severity: diagnostic.category === ts7.DiagnosticCategory.Error ? "error" : diagnostic.category === ts7.DiagnosticCategory.Warning ? "warning" : "info",
+    message,
+    ...relativeFile ? { file: relativeFile } : {},
+    ...start ? { line: start.line + 1, column: start.character + 1 } : {}
+  };
+}
+function sanitizeCompilerMessage(message, root) {
+  return redactAbsolutePathsInText(message, root) || "TypeScript reported a compiler diagnostic.";
+}
+
+// src/analyze.ts
+async function analyzeDefaultCompilerUnit(input) {
+  const pipeline = defaultAnalyzerPipeline();
+  const contribution = await analyzeCompilerUnit({
+    ...input,
+    analyzers: pipeline.analyzers,
+    trustedInternalAnalyzers: pipeline.methods,
+    // We expose type facts and syntactic diagnostics, not TS JSDoc link diagnostics or prose.
+    // This mode still parses all JavaScript JSDoc, which can define types.
+    semanticResolver: new TypeScriptSemanticResolver(ts8.JSDocParsingMode.ParseForTypeInfo)
+  });
+  return {
+    contribution,
+    files: [...input.preparedByAbsolute.values()].map((source) => source.file)
+  };
+}
+async function analyzeCompilerUnit(options) {
+  const { unit } = options;
+  const semantic = await options.semanticResolver.resolve({
+    root: options.root,
+    sourceFiles: unit.sourceFiles,
+    ...unit.record.config ? { tsconfig: unit.record.config } : {},
+    compilerUnit: unit.record.id
+  });
+  const { program, checker } = semantic;
+  const resolveModule = semantic.resolveModule ?? createBoundedModuleResolver(
+    options.root,
+    path9.resolve(options.root, unit.record.root),
+    program.getCompilerOptions()
+  );
+  const diagnostics = [...semantic.diagnostics];
+  const symbols = [];
+  const relations = [];
+  for (const absolutePath of unit.ownedFiles) {
+    const source = options.preparedByAbsolute.get(absolutePath);
+    if (!source) continue;
+    const sourceFile = program.getSourceFile(source.absolutePath);
+    if (!sourceFile) {
+      diagnostics.push({
+        schemaVersion: SCHEMA_VERSION,
+        code: "analysis-error",
+        severity: "error",
+        message: "TypeScript did not include this selected source file in the owning compiler unit.",
+        file: source.relativePath
+      });
+      continue;
+    }
+    const sourceDiagnostics = parseDiagnostics(program, sourceFile, options.root);
+    diagnostics.push(...sourceDiagnostics);
+    const syntax = source.syntax ?? syntaxFromProgram(sourceFile, sourceDiagnostics);
+    source.file.syntax = {
+      parser: sanitizePersistedText(syntax.parser, options.root),
+      factCount: syntax.facts.length,
+      hadErrors: syntax.hadErrors,
+      ...syntax.fallbackFrom ? { fallbackFrom: sanitizePersistedText(syntax.fallbackFrom, options.root) } : {}
+    };
+    const context = {
+      root: options.root,
+      relativePath: source.relativePath,
+      sourceFile,
+      program,
+      checker,
+      sourceHash: source.hash,
+      file: source.file,
+      packageDependencies: options.packageDependencies,
+      syntax,
+      includePrivateSymbols: options.includePrivateSymbols,
+      compilerUnit: unit.record,
+      indexedSourcePaths: options.indexedSourcePaths,
+      resolveModule
+    };
+    const structure = extractFileStructure(context);
+    source.file.imports = structure.imports;
+    source.file.exports = structure.exports;
+    source.file.env = structure.env;
+    source.file.operations = structure.operations;
+    diagnostics.push(...structure.diagnostics);
+    relations.push(...structure.relations);
+    for (const analyzer of options.analyzers) {
+      const trustedSupport = trustedAnalyzerMethods(analyzer, options.trustedInternalAnalyzers);
+      let supported = false;
+      try {
+        supported = trustedSupport ? trustedSupport.supports(context) : analyzer.supports(isolateCustomAnalyzerContext(context));
+      } catch {
+        diagnostics.push({
+          schemaVersion: SCHEMA_VERSION,
+          code: "analysis-error",
+          severity: "warning",
+          message: `Analyzer ${analyzer.name} failed during capability detection; its contribution was skipped.`,
+          file: source.relativePath
+        });
+        continue;
+      }
+      if (!supported || !analyzerEnabled(analyzer, options.selectedFrameworks)) continue;
+      try {
+        const trustedAnalysis = trustedAnalyzerMethods(analyzer, options.trustedInternalAnalyzers);
+        const rawContribution = trustedAnalysis ? await trustedAnalysis.analyze(context) : await analyzer.analyze(isolateCustomAnalyzerContext(context));
+        const contribution = trustedAnalysis ? rawContribution : sanitizeCustomContribution(
+          rawContribution,
+          options.root,
+          analyzer.name,
+          source,
+          symbols
+        );
+        symbols.push(...contribution.symbols ?? []);
+        relations.push(...contribution.relations ?? []);
+        diagnostics.push(...contribution.diagnostics ?? []);
+        source.file.frameworks.push(...contribution.frameworks ?? []);
+      } catch {
+        diagnostics.push({
+          schemaVersion: SCHEMA_VERSION,
+          code: "analysis-error",
+          severity: "warning",
+          message: `Analyzer ${analyzer.name} failed; its contribution was skipped.`,
+          file: source.relativePath
+        });
+      }
+    }
+    source.file.frameworks = [...new Set(source.file.frameworks)].sort();
+  }
+  return {
+    pathAliases: semantic.pathAliases,
+    diagnostics,
+    symbols,
+    relations,
+    semanticInputs: semantic.semanticInputs?.() ?? []
+  };
+}
+function isolateCustomAnalyzerContext(context) {
+  return {
+    ...context,
+    file: structuredClone(context.file),
+    syntax: structuredClone(context.syntax),
+    compilerUnit: structuredClone(context.compilerUnit),
+    packageDependencies: new Set(context.packageDependencies),
+    ...context.indexedSourcePaths ? { indexedSourcePaths: new Set(context.indexedSourcePaths) } : {}
+  };
+}
+function sanitizeCustomContribution(contribution, root, analyzerName, source, knownSymbols) {
+  const sourceFileId = fileId(source.relativePath);
+  const localSymbolIds = new Set(
+    knownSymbols.filter((symbol) => symbol.file === source.relativePath).map((symbol) => symbol.id)
+  );
+  const localSymbols = new Map(
+    knownSymbols.filter((symbol) => symbol.file === source.relativePath).map((symbol) => [symbol.id, symbol])
+  );
+  const symbolIds = /* @__PURE__ */ new Map();
+  const warnings = [];
+  const pushWarning = (message) => {
+    warnings.push({
+      schemaVersion: SCHEMA_VERSION,
+      code: "analysis-error",
+      severity: "warning",
+      message: sanitizePersistedText(message, root),
+      file: source.relativePath
+    });
+  };
+  const rangeFitsSource = (range) => range.startLine >= 1 && range.endLine >= range.startLine && range.endLine <= source.file.lines && (range.endLine !== range.startLine || range.endColumn >= range.startColumn);
+  const sanitizeEndpoint = (value) => symbolIds.get(value) ?? sanitizeCustomIdentifier(value, root);
+  const symbols = [];
+  for (const raw of contribution.symbols ?? []) {
+    const sanitized = {
+      ...raw,
+      id: sanitizeCustomIdentifier(raw.id, root),
+      name: sanitizePersistedText(raw.name, root),
+      ...raw.signature ? { signature: sanitizePersistedText(raw.signature, root) } : {},
+      ...raw.documentation ? { documentation: sanitizePersistedText(raw.documentation, root) } : {},
+      facts: Object.fromEntries(
+        Object.entries(raw.facts).map(([key, value]) => [
+          sanitizePersistedText(key, root),
+          sanitizeJsonValue(value, root)
+        ])
+      )
+    };
+    const parsed = SymbolRecordSchema.safeParse(sanitized);
+    if (!parsed.success) {
+      pushWarning(`Analyzer ${analyzerName} emitted an invalid custom symbol.`);
+      continue;
+    }
+    if (parsed.data.file !== source.relativePath) {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted a custom symbol for non-local file ${parsed.data.file}.`
+      );
+      continue;
+    }
+    if (parsed.data.sourceHash !== source.hash) {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted a custom symbol with a source hash mismatch for ${parsed.data.id}.`
+      );
+      continue;
+    }
+    if (!rangeFitsSource(parsed.data.range)) {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted a custom symbol with out-of-bounds source range for ${parsed.data.id}.`
+      );
+      continue;
+    }
+    symbols.push(parsed.data);
+    symbolIds.set(raw.id, parsed.data.id);
+    localSymbolIds.add(parsed.data.id);
+    localSymbols.set(parsed.data.id, parsed.data);
+  }
+  const relations = [];
+  for (const raw of contribution.relations ?? []) {
+    const relation2 = {
+      ...raw,
+      from: sanitizeEndpoint(raw.from),
+      to: sanitizeEndpoint(raw.to),
+      origin: {
+        ...raw.origin,
+        explanation: sanitizePersistedText(raw.origin.explanation, root),
+        analyzer: sanitizePersistedText(raw.origin.analyzer, root)
+      }
+    };
+    const parsed = RelationRecordSchema.safeParse(relation2);
+    if (!parsed.success) {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted an invalid custom relation from ${relation2.from} to ${relation2.to}.`
+      );
+      continue;
+    }
+    if (parsed.data.origin.file !== source.relativePath || parsed.data.origin.line !== parsed.data.origin.range.startLine || parsed.data.origin.range.startLine < 1 || parsed.data.origin.range.endLine > source.file.lines) {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted a custom relation with invalid evidence bounds for ${parsed.data.from} -> ${parsed.data.to}.`
+      );
+      continue;
+    }
+    if (parsed.data.type === "imports") {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted a custom imports relation; imports are core-owned and were skipped.`
+      );
+      continue;
+    } else if (parsed.data.type === "contains" || parsed.data.type === "exports") {
+      const targetSymbol = localSymbols.get(parsed.data.to);
+      if (!targetSymbol || !rangesEqual2(parsed.data.origin.range, targetSymbol.range)) {
+        pushWarning(
+          `Analyzer ${analyzerName} emitted an invalid custom structural relation ${parsed.data.type} ${parsed.data.from} -> ${parsed.data.to}.`
+        );
+        continue;
+      }
+      if (parsed.data.type === "exports") {
+        if (parsed.data.from !== sourceFileId || !targetSymbol.exported) {
+          pushWarning(
+            `Analyzer ${analyzerName} emitted an invalid custom export relation ${parsed.data.from} -> ${parsed.data.to}.`
+          );
+          continue;
+        }
+      } else if (parsed.data.from !== sourceFileId) {
+        const parentSymbol = localSymbols.get(parsed.data.from);
+        if (!parentSymbol || !rangeContains2(parentSymbol.range, parsed.data.origin.range)) {
+          pushWarning(
+            `Analyzer ${analyzerName} emitted an invalid custom containment relation ${parsed.data.from} -> ${parsed.data.to}.`
+          );
+          continue;
+        }
+      } else if (!localSymbolIds.has(parsed.data.to)) {
+        pushWarning(
+          `Analyzer ${analyzerName} emitted an invalid custom containment relation from file to non-local symbol ${parsed.data.to}.`
+        );
+        continue;
+      }
+    }
+    relations.push(parsed.data);
+  }
+  const diagnostics = [];
+  for (const raw of contribution.diagnostics ?? []) {
+    const diagnostic = {
+      ...raw,
+      message: sanitizePersistedText(raw.message, root)
+    };
+    const parsed = DiagnosticRecordSchema.safeParse(diagnostic);
+    if (!parsed.success) {
+      pushWarning(`Analyzer ${analyzerName} emitted an invalid custom diagnostic.`);
+      continue;
+    }
+    if (parsed.data.file && parsed.data.file !== source.relativePath) {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted a custom diagnostic for non-local file ${parsed.data.file}.`
+      );
+      continue;
+    }
+    if (parsed.data.file && parsed.data.line && parsed.data.line > source.file.lines) {
+      pushWarning(
+        `Analyzer ${analyzerName} emitted a custom diagnostic with out-of-bounds line ${parsed.data.line}.`
+      );
+      continue;
+    }
+    diagnostics.push(parsed.data);
+  }
+  const frameworks = [];
+  for (const rawFramework of contribution.frameworks ?? []) {
+    const parsed = FrameworkSchema.safeParse(rawFramework);
+    if (!parsed.success) {
+      pushWarning(`Analyzer ${analyzerName} emitted an invalid custom framework ${rawFramework}.`);
+      continue;
+    }
+    frameworks.push(parsed.data);
+  }
+  return {
+    ...symbols.length ? { symbols } : {},
+    ...relations.length ? { relations } : {},
+    ...diagnostics.length || warnings.length ? {
+      diagnostics: [...diagnostics, ...warnings]
+    } : {},
+    ...frameworks.length ? { frameworks } : {}
+  };
+}
+function sanitizeCustomIdentifier(value, root) {
+  if (value.startsWith("route:")) {
+    const route = value.slice("route:".length);
+    return looksLikeHostFilePath(route, root) ? "route:<redacted>" : value;
+  }
+  if (value.startsWith("external:")) {
+    const separator = value.lastIndexOf("#");
+    const moduleName = value.slice("external:".length, separator > 0 ? separator : void 0);
+    const exported = separator > 0 ? value.slice(separator + 1) : "default";
+    const safeModule = isAbsolutePath(moduleName) || hasEmbeddedAbsolutePath(moduleName) ? "<absolute-import>" : sanitizePersistedText(moduleName, root);
+    return `external:${safeModule}#${sanitizePersistedText(exported, root)}`;
+  }
+  const prefixEnd = value.indexOf(":");
+  const nameStart = value.lastIndexOf("#");
+  if (prefixEnd >= 0) {
+    const pathEnd = nameStart > prefixEnd ? nameStart : value.length;
+    const candidatePath = value.slice(prefixEnd + 1, pathEnd);
+    if (isAbsolutePath(candidatePath) || hasEmbeddedAbsolutePath(candidatePath)) {
+      const safePath = sanitizePersistedText(candidatePath, root);
+      const suffix = nameStart > prefixEnd ? value.slice(nameStart) : "";
+      return `${value.slice(0, prefixEnd + 1)}${safePath}${sanitizePersistedText(suffix, root)}`;
+    }
+  }
+  return sanitizePersistedText(value, root);
+}
+function rangesEqual2(left, right) {
+  return left.startLine === right.startLine && left.startColumn === right.startColumn && left.endLine === right.endLine && left.endColumn === right.endColumn;
+}
+function rangeContains2(outer, inner) {
+  if (outer.startLine > inner.startLine || outer.startLine === inner.startLine && outer.startColumn > inner.startColumn)
+    return false;
+  if (outer.endLine < inner.endLine || outer.endLine === inner.endLine && outer.endColumn < inner.endColumn)
+    return false;
+  return true;
+}
+function sanitizeJsonValue(value, root) {
+  if (typeof value === "string") return sanitizePersistedText(value, root);
+  if (Array.isArray(value)) return value.map((item) => sanitizeJsonValue(item, root));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        sanitizePersistedText(key, root),
+        sanitizeJsonValue(item, root)
+      ])
+    );
+  }
+  return value;
+}
+var canonicalCoreAnalyzerMethods = {
+  supports: CoreAnalyzer.prototype.supports.bind(CoreAnalyzer.prototype),
+  analyze: CoreAnalyzer.prototype.analyze.bind(CoreAnalyzer.prototype)
+};
+var canonicalReactAnalyzerMethods = {
+  supports: ReactAnalyzer.prototype.supports.bind(ReactAnalyzer.prototype),
+  analyze: ReactAnalyzer.prototype.analyze.bind(ReactAnalyzer.prototype)
+};
+function defaultAnalyzerPipeline() {
+  const core = new CoreAnalyzer();
+  const react = new ReactAnalyzer();
+  return {
+    analyzers: [core, react],
+    methods: /* @__PURE__ */ new Map([
+      [core, canonicalCoreAnalyzerMethods],
+      [react, canonicalReactAnalyzerMethods]
+    ])
+  };
+}
+function analyzerEnabled(analyzer, frameworks) {
+  if (analyzer instanceof CoreAnalyzer) return true;
+  const name = analyzer.name.toLowerCase();
+  if (name.includes("react")) return frameworks.includes("react") || frameworks.includes("nextjs");
+  if (name.includes("next")) return frameworks.includes("nextjs");
+  if (name.includes("nest")) return frameworks.includes("nestjs");
+  return true;
+}
+function trustedAnalyzerMethods(analyzer, internal) {
+  const internalMethods = internal.get(analyzer);
+  if (internalMethods) return internalMethods;
+  return trustedNextJsAnalyzerMethods(analyzer) ?? trustedNestJsAnalyzerMethods(analyzer);
+}
+function parseDiagnostics(program, sourceFile, root) {
+  return program.getSyntacticDiagnostics(sourceFile).map((diagnostic) => compilerDiagnostic(diagnostic, root));
+}
+function syntaxFromProgram(sourceFile, diagnostics) {
+  const parser = "typescript-compiler-syntax";
+  const facts = [];
+  for (const statement of sourceFile.statements) {
+    const kind = ts8.isImportDeclaration(statement) ? "import" : ts8.isExportDeclaration(statement) || ts8.isExportAssignment(statement) ? "export" : isTopLevelDeclaration(statement) ? "declaration" : void 0;
+    if (!kind) continue;
+    const name = syntaxStatementName(statement);
+    facts.push({
+      kind,
+      nodeType: ts8.SyntaxKind[statement.kind],
+      ...name ? { name } : {},
+      range: sourceRange(sourceFile, statement),
+      evidence: { parser, exact: true }
+    });
+  }
+  for (const diagnostic of diagnostics) {
+    facts.push({
+      kind: "parse-error",
+      nodeType: "typescript-diagnostic",
+      range: {
+        startLine: diagnostic.line ?? 1,
+        startColumn: diagnostic.column ?? 1,
+        endLine: diagnostic.line ?? 1,
+        endColumn: diagnostic.column ?? 1
+      },
+      evidence: { parser, exact: true }
+    });
+  }
+  return {
+    parser,
+    facts,
+    issues: diagnostics.map((diagnostic) => ({ message: diagnostic.message })),
+    hadErrors: diagnostics.length > 0
+  };
+}
+function isTopLevelDeclaration(statement) {
+  return ts8.isFunctionDeclaration(statement) || ts8.isClassDeclaration(statement) || ts8.isInterfaceDeclaration(statement) || ts8.isTypeAliasDeclaration(statement) || ts8.isVariableStatement(statement);
+}
+function syntaxStatementName(statement) {
+  if (ts8.isImportDeclaration(statement) && ts8.isStringLiteral(statement.moduleSpecifier)) {
+    return statement.moduleSpecifier.text;
+  }
+  if (ts8.isExportAssignment(statement)) return "default";
+  if (ts8.isExportDeclaration(statement)) {
+    return statement.moduleSpecifier && ts8.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : "export";
+  }
+  if (ts8.isVariableStatement(statement)) {
+    return statement.declarationList.declarations.map((declaration) => ts8.isIdentifier(declaration.name) ? declaration.name.text : void 0).filter((name2) => name2 !== void 0).join(",");
+  }
+  const name = statement.name;
+  return name && ts8.isIdentifier(name) ? name.text : void 0;
+}
+function sourceRange(sourceFile, node) {
+  const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile, false));
+  const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+  return {
+    startLine: start.line + 1,
+    startColumn: start.character + 1,
+    endLine: end.line + 1,
+    endColumn: end.character + 1
+  };
+}
+function sanitizePersistedText(value, root) {
+  return redactAbsolutePathsInText(value, root) || "<redacted>";
+}
+
+// src/compiler-worker.ts
+if (!parentPort) throw new Error("Compiler worker requires a parent port.");
+var result = await analyzeDefaultCompilerUnit(workerData);
+var session = new Session();
+session.connect();
+try {
+  await session.post("HeapProfiler.collectGarbage");
+} finally {
+  session.disconnect();
+}
+parentPort.postMessage(result);
+parentPort.close();
+//# sourceMappingURL=compiler-worker.js.map