@c4a/extract-ts 0.7.5 → 0.7.9

package/index.js

@@ -11444,15 +11444,21 @@ function replaceWithCount(value, pattern, replacement, count) {
     return replacement(...args.slice(0, -2));
   });
 }
+var SECRET_TEXT_KEY = "(?:[A-Za-z0-9_.-]*(?:password|passwd|pwd|secret|token|credential|cookie)[A-Za-z0-9_.-]*|api[-_]?key|access[-_]?(?:key|token)|private[-_]?key|client[-_]?secret|authorization)";
+var SECRET_TEXT_ASSIGNMENT = `(?:=\\s*|:\\s+(?=\\S)|:\\s*(?=["']))`;
+var AUTHORIZATION_TEXT_PATTERN = new RegExp(`(\\bauthorization\\s*:\\s*(?:bearer|basic)\\s+)` + `(?!${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})[^\\s,;]+`, "giu");
+var QUERY_SECRET_TEXT_PATTERN = new RegExp(`([?&](?:access_token|refresh_token|api_key|password|secret)=)` + `(?!${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})[^&#\\s]+`, "giu");
+var ASSIGNMENT_SECRET_TEXT_PATTERN = new RegExp(`((?:["']?${SECRET_TEXT_KEY}["']?)\\s*${SECRET_TEXT_ASSIGNMENT})` + `(?!["']?${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})` + `(?:"(?:\\\\.|[^"])*"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)`, "giu");
 function redactKnownText(value, count) {
+  if (!value.includes(":") && !value.includes("=") && !value.includes("-----BEGIN ")) {
+    return value;
+  }
   let output = value;
   output = replaceWithCount(output, /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/gu, INDEXER_OUTPUT_REDACTION_MARKER, count);
-  output = replaceWithCount(output, new RegExp(`(\\bauthorization\\s*:\\s*(?:bearer|basic)\\s+)` + `(?!${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})[^\\s,;]+`, "giu"), (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  output = replaceWithCount(output, AUTHORIZATION_TEXT_PATTERN, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
   output = replaceWithCount(output, /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}@`, count);
-  output = replaceWithCount(output, new RegExp(`([?&](?:access_token|refresh_token|api_key|password|secret)=)` + `(?!${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})[^&#\\s]+`, "giu"), (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
-  const key = "(?:[A-Za-z0-9_.-]*(?:password|passwd|pwd|secret|token|credential|cookie)[A-Za-z0-9_.-]*|api[-_]?key|access[-_]?(?:key|token)|private[-_]?key|client[-_]?secret|authorization)";
-  const assignment = `(?:=\\s*|:\\s+(?=\\S)|:\\s*(?=["']))`;
-  output = replaceWithCount(output, new RegExp(`((?:["']?${key}["']?)\\s*${assignment})` + `(?!["']?${escapeRegExp(INDEXER_OUTPUT_REDACTION_MARKER)})` + `(?:"(?:\\\\.|[^"])*"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)`, "giu"), (_match, prefix) => `${prefix}"${INDEXER_OUTPUT_REDACTION_MARKER}"`, count);
+  output = replaceWithCount(output, QUERY_SECRET_TEXT_PATTERN, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  output = replaceWithCount(output, ASSIGNMENT_SECRET_TEXT_PATTERN, (_match, prefix) => `${prefix}"${INDEXER_OUTPUT_REDACTION_MARKER}"`, count);
   return output;
 }
 function redactBlockedText(value, blocked, count) {
@@ -12532,238 +12538,1006 @@ var detectEntries = async (manifest, fs) => {
   };
 };
 
-// ../extract/src/types.ts
-var symbolKindSchema2 = exports_external.enum(Object.values(SymbolKind));
-var visibilitySchema2 = exports_external.enum(Object.values(Visibility));
-var relationTypeSchema = exports_external.enum([
-  "imports" /* Imports */,
-  "imports_type" /* ImportsType */,
-  "calls" /* Calls */,
-  "extends" /* Extends */,
-  "implements" /* Implements */,
-  "param_type" /* ParamType */,
-  "return_type" /* ReturnType */,
-  "of_type" /* OfType */,
-  "depends_on" /* DependsOn */,
-  "contains" /* Contains */
-]);
-var relationSourceSchema = exports_external.enum([
-  "ast" /* Ast */,
-  "doc" /* Doc */,
-  "manual" /* Manual */
-]);
-var packageKindSchema2 = exports_external.enum(Object.values(PackageKind));
-var symbolParamSchema = exports_external.object({
-  name: exports_external.string().min(1),
-  type: exports_external.string().min(1).nullable()
-});
-var symbolInfoSchema = exports_external.lazy(() => exports_external.object({
-  name: exports_external.string().min(1),
-  kind: symbolKindSchema2,
-  visibility: visibilitySchema2,
-  file: exports_external.string().min(1),
-  line: exports_external.number().int().positive(),
-  endLine: exports_external.number().int().positive(),
-  members: exports_external.array(symbolInfoSchema).optional(),
-  params: exports_external.array(symbolParamSchema).optional(),
-  returnType: exports_external.string().min(1).nullable().optional(),
-  typeAnnotation: exports_external.string().min(1).nullable().optional(),
-  extends: exports_external.string().min(1).nullable().optional(),
-  implements: exports_external.array(exports_external.string().min(1)).optional(),
-  doc: exports_external.string().nullable().optional(),
-  propsType: exports_external.string().min(1).nullable().optional(),
-  unionValues: exports_external.array(exports_external.string()).optional(),
-  initializer: exports_external.string().min(1).nullable().optional(),
-  signature: exports_external.string().min(1).nullable().optional()
-}));
-var relationInfoSchema = exports_external.object({
-  type: relationTypeSchema,
-  from: exports_external.string().min(1),
-  to: exports_external.string().min(1),
-  isExternal: exports_external.boolean(),
-  grounding: groundingSchema,
-  confidence: exports_external.number().min(0).max(1),
-  source: relationSourceSchema,
-  line: exports_external.number().int().positive().optional()
-});
-var fileInfoSchema = exports_external.object({
-  path: exports_external.string().min(1),
-  language: exports_external.string().min(1),
-  lines: exports_external.number().int().nonnegative()
-});
-var extractionDiagnosticSchema = exports_external.object({
-  code: exports_external.string().min(1),
-  severity: exports_external.enum(["info", "warning", "error"]),
-  file: exports_external.string().min(1),
-  line: exports_external.number().int().positive(),
-  column: exports_external.number().int().positive()
-});
-var extractionCoverageSchema = exports_external.object({
-  tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
-  capabilities: exports_external.array(exports_external.string().min(1)),
-  files: exports_external.array(exports_external.object({
-    path: exports_external.string().min(1),
-    disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
-    diagnosticCodes: exports_external.array(exports_external.string().min(1))
-  })),
-  diagnostics: exports_external.array(extractionDiagnosticSchema)
-});
-var extractionMetaSchema = exports_external.object({
-  extractedAt: exports_external.string().datetime(),
-  pluginId: exports_external.string().min(1),
-  commitHash: exports_external.string().min(1).nullable(),
-  language: exports_external.string().min(1)
-});
-var extractionPackageSchema = exports_external.object({
-  name: exports_external.string().min(1),
-  kind: packageKindSchema2,
-  language: exports_external.string().min(1),
-  version: exports_external.string().min(1).optional()
-});
-var extractionStatsSchema = exports_external.object({
-  files: exports_external.number().int().nonnegative(),
-  lines: exports_external.number().int().nonnegative(),
-  exportedSymbols: exports_external.number().int().nonnegative(),
-  internalSymbols: exports_external.number().int().nonnegative(),
-  relations: exports_external.number().int().nonnegative()
-});
-var extractionResultSchema = exports_external.object({
-  version: exports_external.literal("2"),
-  meta: extractionMetaSchema,
-  package: extractionPackageSchema,
-  files: exports_external.array(fileInfoSchema),
-  symbols: exports_external.array(symbolInfoSchema),
-  relations: exports_external.array(relationInfoSchema),
-  coverage: extractionCoverageSchema.optional(),
-  stats: extractionStatsSchema
-});
-var digestStatsSchema = exports_external.object({
-  files: exports_external.number().int().nonnegative(),
-  lines: exports_external.number().int().nonnegative(),
-  exported_count: exports_external.number().int().nonnegative(),
-  internal_count: exports_external.number().int().nonnegative(),
-  relations: exports_external.number().int().nonnegative()
-});
-var digestDataSchema = exports_external.object({
-  version: exports_external.literal("2"),
-  meta: extractionMetaSchema,
-  package: extractionPackageSchema,
-  files: exports_external.array(fileInfoSchema),
-  symbols: exports_external.array(symbolInfoSchema),
-  relations: exports_external.array(relationInfoSchema),
-  coverage: extractionCoverageSchema.optional(),
-  stats: digestStatsSchema
-});
-var symbolDiffSchema = exports_external.object({
-  added: exports_external.array(exports_external.string().min(1)),
-  removed: exports_external.array(exports_external.string().min(1))
-});
-// ../extract/src/protocol.ts
-var packageKindSchema3 = exports_external.enum(Object.values(PackageKind));
-var manifestTypeSchema = exports_external.enum([
-  "package.json",
-  "pyproject.toml",
-  "Cargo.toml",
-  "go.mod",
-  "pom.xml"
-]);
-var entryFileSchema = exports_external.object({
-  path: exports_external.string().min(1),
-  subpath: exports_external.string().min(1),
-  type: exports_external.enum(["library", "cli", "service", "webapp"])
-});
-var manifestInfoSchema = exports_external.object({
-  type: manifestTypeSchema,
-  path: exports_external.string().min(1),
-  content: exports_external.record(exports_external.unknown())
-});
-var sourceInfoSchema = exports_external.object({
-  path: exports_external.string().min(1),
-  manifests: exports_external.array(manifestInfoSchema),
-  language: exports_external.string().min(1).optional()
-});
-var entryDetectionResultSchema = exports_external.lazy(() => exports_external.object({
-  package: exports_external.object({
-    name: exports_external.string().min(1),
-    kind: packageKindSchema3,
-    language: exports_external.string().min(1),
-    version: exports_external.string().min(1).optional()
-  }),
-  entries: exports_external.array(entryFileSchema),
-  subPackages: exports_external.array(entryDetectionResultSchema).optional()
-}));
-var patternDetectionResultSchema = exports_external.object({
-  endpoints: exports_external.array(exports_external.object({
-    handler: exports_external.string().min(1),
-    method: exports_external.string().min(1),
-    path: exports_external.string().min(1),
-    file: exports_external.string().min(1),
-    line: exports_external.number().int().positive()
-  })).optional(),
-  implicitDeps: exports_external.array(exports_external.object({
-    verb: exports_external.enum(["produce", "consume", "depends_on", "serve"]),
-    target: exports_external.string().min(1),
-    file: exports_external.string().min(1),
-    line: exports_external.number().int().positive()
-  })).optional(),
-  configRefs: exports_external.array(exports_external.object({
-    key: exports_external.string().min(1),
-    file: exports_external.string().min(1),
-    line: exports_external.number().int().positive()
-  })).optional()
-});
-// ../extract/src/registry.ts
-var MANIFEST_LANGUAGE_CANDIDATES = {
-  "package.json": ["typescript", "tsx", "javascript", "jsx"],
-  "pyproject.toml": ["python"],
-  "Cargo.toml": ["rust"],
-  "go.mod": ["go"],
-  "pom.xml": ["java"]
-};
-
-class ExtractionPluginRegistry {
-  #plugins = [];
-  register(plugin) {
-    this.#plugins.push(plugin);
+// src/componentContract.ts
+import ts from "typescript";
+function componentPropsNode(node2) {
+  if (node2 === undefined || !ts.isTypeReferenceNode(node2))
+    return;
+  if (!["FC", "React.FC", "FunctionComponent", "React.FunctionComponent"].includes(node2.typeName.getText()))
+    return;
+  return node2.typeArguments?.length === 1 ? node2.typeArguments[0] : undefined;
+}
+function componentLocalPropsNode(node2, checker) {
+  if (ts.isParenthesizedTypeNode(node2))
+    return componentLocalPropsNode(node2.type, checker);
+  if (!ts.isTypeReferenceNode(node2) || node2.typeArguments?.length !== 1)
+    return;
+  const name = node2.typeName;
+  const identifier = ts.isIdentifier(name) ? name : ts.isIdentifier(name.left) ? name.left : undefined;
+  if (identifier === undefined)
+    return;
+  const imported = checker.getSymbolAtLocation(identifier)?.declarations?.find((declaration) => ts.isImportSpecifier(declaration) || ts.isNamespaceImport(declaration) || ts.isImportClause(declaration));
+  if (imported === undefined)
+    return;
+  let owner = imported;
+  while (!ts.isImportDeclaration(owner) && owner.parent !== undefined)
+    owner = owner.parent;
+  if (!ts.isImportDeclaration(owner) || !ts.isStringLiteral(owner.moduleSpecifier) || owner.moduleSpecifier.text !== "react")
+    return;
+  const wrapper = ts.isIdentifier(name) ? ts.isImportSpecifier(imported) ? (imported.propertyName ?? imported.name).text : undefined : ts.isNamespaceImport(imported) || ts.isImportClause(imported) ? name.right.text : undefined;
+  return wrapper === "PropsWithChildren" ? node2.typeArguments[0] : undefined;
+}
+function componentPropsName(annotation) {
+  const source = ts.createSourceFile("contract.ts", `type Contract = ${annotation};`, ts.ScriptTarget.Latest, true);
+  const declaration = source.statements[0];
+  if (declaration === undefined || !ts.isTypeAliasDeclaration(declaration))
+    return;
+  const props = componentPropsNode(declaration.type);
+  return props !== undefined && ts.isTypeReferenceNode(props) && ts.isIdentifier(props.typeName) && !props.typeArguments?.length ? props.typeName.text : undefined;
+}
+function componentBindingDefaults(pattern) {
+  const source = ts.createSourceFile("contract.ts", `function input(${pattern}) {}`, ts.ScriptTarget.Latest, true);
+  const diagnostics = source.parseDiagnostics;
+  const fn = source.statements[0];
+  if (diagnostics.length || source.statements.length !== 1 || fn === undefined || !ts.isFunctionDeclaration(fn) || fn.parameters.length !== 1 || fn.body?.statements.length)
+    return {};
+  const name = fn.parameters[0].name;
+  return componentDefaultsFromBinding(name, source);
+}
+function componentDefaultsFromBinding(name, source) {
+  if (!ts.isObjectBindingPattern(name))
+    return {};
+  const defaults = Object.create(null);
+  for (const element of name.elements) {
+    const key = element.propertyName ?? element.name;
+    if (element.initializer === undefined || element.dotDotDotToken !== undefined || !ts.isIdentifier(key) && !ts.isStringLiteral(key) && !ts.isNumericLiteral(key))
+      continue;
+    defaults[key.text] = element.initializer.getText(source);
   }
-  resolve(source) {
-    const declaredLanguage = source.language?.toLowerCase();
-    const manifestLanguages = new Set(source.manifests.flatMap((manifest) => MANIFEST_LANGUAGE_CANDIDATES[manifest.type] ?? []));
-    const candidates = this.#plugins.filter((plugin) => {
-      const pluginLanguages = plugin.languages.map((language) => language.toLowerCase());
-      if (declaredLanguage) {
-        return pluginLanguages.includes(declaredLanguage);
-      }
-      if (manifestLanguages.size === 0) {
-        return true;
-      }
-      return pluginLanguages.some((language) => manifestLanguages.has(language));
-    });
-    for (const plugin of candidates) {
-      if (plugin.canHandle(source)) {
-        return plugin;
+  return defaults;
+}
+
+// src/federationContracts.ts
+import ts2 from "typescript";
+function federationContracts(source) {
+  const factories = new Set;
+  for (const statement of source.statements) {
+    if (!ts2.isImportDeclaration(statement) || !ts2.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const module = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (module === "webpack" && clause?.name !== undefined)
+      factories.add(`${clause.name.text}.container.ModuleFederationPlugin`);
+    if (!["webpack", "@module-federation/enhanced/webpack", "@module-federation/enhanced/rspack", "@module-federation/vite"].includes(module))
+      continue;
+    if (clause?.namedBindings !== undefined && ts2.isNamedImports(clause.namedBindings)) {
+      for (const item of clause.namedBindings.elements) {
+        if (["ModuleFederationPlugin", "federation"].includes((item.propertyName ?? item.name).text))
+          factories.add(item.name.text);
+        if (module === "webpack" && (item.propertyName ?? item.name).text === "container")
+          factories.add(`${item.name.text}.ModuleFederationPlugin`);
       }
     }
-    return null;
-  }
-  list() {
-    return [...this.#plugins];
   }
+  const results = [];
+  const visit = (node2) => {
+    if ((ts2.isCallExpression(node2) || ts2.isNewExpression(node2)) && factories.has(node2.expression.getText(source))) {
+      const config = node2.arguments?.[0];
+      if (config !== undefined && ts2.isObjectLiteralExpression(config)) {
+        const members = [];
+        for (const property of config.properties) {
+          if (!ts2.isPropertyAssignment(property))
+            continue;
+          const key = property.name.getText(source).replace(/^['"]|['"]$/gu, "");
+          if (!["name", "filename", "exposes", "remotes", "shared"].includes(key))
+            continue;
+          const properties = ts2.isObjectLiteralExpression(property.initializer) ? property.initializer.properties.filter(ts2.isPropertyAssignment) : [property];
+          for (const value of properties)
+            members.push({
+              name: value === property ? key : `${key}.${value.name.getText(source).replace(/^['"]|['"]$/gu, "")}`,
+              kind: "config" /* Config */,
+              visibility: "exported" /* Exported */,
+              file: source.fileName.replace(/^\//u, ""),
+              line: source.getLineAndCharacterOfPosition(value.getStart()).line + 1,
+              endLine: source.getLineAndCharacterOfPosition(value.end).line + 1,
+              typeAnnotation: value.initializer.getText(source)
+            });
+        }
+        results.push({
+          name: "Module federation configuration",
+          kind: "config" /* Config */,
+          visibility: "exported" /* Exported */,
+          file: source.fileName.replace(/^\//u, ""),
+          line: source.getLineAndCharacterOfPosition(node2.getStart()).line + 1,
+          endLine: source.getLineAndCharacterOfPosition(node2.end).line + 1,
+          signature: node2.expression.getText(source),
+          members
+        });
+      }
+    }
+    ts2.forEachChild(node2, visit);
+  };
+  visit(source);
+  return results;
 }
-// ../extract/src/scanner.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-var SUPPORTED_EXTENSIONS = new Set([
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs"
-]);
+
+// src/publicContracts.ts
+import { posix as posix3 } from "node:path";
+import ts5 from "typescript";
+
+// src/typeReferences.ts
+import ts3 from "typescript";
+var BUILTIN_TYPES = new Set([
+  "Array",
+  "Boolean",
+  "Date",
+  "Error",
+  "Map",
+  "Number",
+  "Object",
+  "Promise",
+  "ReadonlyArray",
+  "Record",
+  "Set",
+  "String"
+]);
+function referencedTypeNames(text) {
+  if (!text)
+    return [];
+  const file = ts3.createSourceFile("type.ts", `type __Value = ${text};`, ts3.ScriptTarget.Latest, true);
+  const declaration = file.statements[0];
+  if (!declaration || !ts3.isTypeAliasDeclaration(declaration))
+    return [];
+  const result = new Set;
+  const visit = (node2, bound) => {
+    const scope = new Set(bound);
+    if ("typeParameters" in node2) {
+      for (const parameter of node2.typeParameters ?? []) {
+        scope.add(parameter.name.text);
+      }
+    }
+    if (ts3.isMappedTypeNode(node2)) {
+      if (node2.typeParameter.constraint)
+        visit(node2.typeParameter.constraint, bound);
+      scope.add(node2.typeParameter.name.text);
+      if (node2.nameType)
+        visit(node2.nameType, scope);
+      if (node2.type)
+        visit(node2.type, scope);
+      return;
+    }
+    if (ts3.isConditionalTypeNode(node2)) {
+      visit(node2.checkType, scope);
+      visit(node2.extendsType, scope);
+      const inferred = new Set(scope);
+      const collect = (child) => {
+        if (ts3.isInferTypeNode(child))
+          inferred.add(child.typeParameter.name.text);
+        else if (!ts3.isConditionalTypeNode(child))
+          ts3.forEachChild(child, collect);
+      };
+      collect(node2.extendsType);
+      visit(node2.trueType, inferred);
+      visit(node2.falseType, scope);
+      return;
+    }
+    if (ts3.isTypeReferenceNode(node2)) {
+      const name = node2.typeName.getText(file);
+      if (!scope.has(name.split(".")[0]) && !BUILTIN_TYPES.has(name))
+        result.add(name);
+    }
+    ts3.forEachChild(node2, (child) => visit(child, scope));
+  };
+  visit(declaration.type, new Set);
+  return [...result];
+}
+
+// src/symbolExtractorAst.ts
+var DECLARATION_TYPES = new Set([
+  "function_declaration",
+  "class_declaration",
+  "interface_declaration",
+  "type_alias_declaration",
+  "enum_declaration",
+  "lexical_declaration"
+]);
+var countLines = (source) => {
+  if (!source)
+    return 0;
+  return source.split(/\r\n|\r|\n/).filter((line) => line.trim().length > 0).length;
+};
+var createRelation = (type, from, to, isExternal, line) => ({
+  type,
+  from,
+  to,
+  isExternal,
+  grounding: "code" /* Code */,
+  confidence: 1,
+  source: "ast" /* Ast */,
+  ...line ? { line } : {}
+});
+var getLine = (node2) => node2.startPosition.row + 1;
+var getEndLine = (node2) => node2.endPosition.row + 1;
+var extractJSDoc = (node2) => {
+  const prev = node2.previousNamedSibling ?? node2.parent?.previousNamedSibling;
+  if (!prev || prev.type !== "comment")
+    return;
+  const text = prev.text;
+  if (!text.startsWith("/**"))
+    return;
+  const cleaned = text.replace(/^\/\*\*\s*/, "").replace(/\s*\*\/$/, "").replace(/^\s*\* ?/gm, "").trim();
+  return cleaned || undefined;
+};
+var extractTypeAnnotation = (node2) => {
+  if (!node2)
+    return null;
+  return node2.text.replace(/^:\s*/, "").trim() || null;
+};
+var getNameNodeText = (node2) => node2?.text?.trim() ? node2.text.trim() : null;
+var getReturnType = (node2) => {
+  const returnNode = node2.childForFieldName("return_type") ?? node2.namedChildren.find((child) => child.type === "type_annotation") ?? null;
+  return extractTypeAnnotation(returnNode);
+};
+var getInitializer = (node2) => node2.childForFieldName("value") ?? node2.namedChildren.find((child) => child.type === "arrow_function" || child.type === "function" || child.type === "call_expression") ?? null;
+var getCallableFromInitializer = (node2) => {
+  if (!node2)
+    return null;
+  if (node2.type === "arrow_function" || node2.type === "function")
+    return node2;
+  if (node2.type === "call_expression") {
+    return node2.namedChildren.find((child) => child.type === "arrow_function" || child.type === "function") ?? null;
+  }
+  return null;
+};
+var getInitializerTypeAnnotation = (node2, options = {}) => {
+  if (!node2 || node2.type !== "call_expression")
+    return null;
+  const typeArguments = node2.namedChildren.find((child) => child.type === "type_arguments") ?? null;
+  if (!typeArguments)
+    return null;
+  if (options.referencesOnly) {
+    return `[${typeArguments.namedChildren.filter((child) => child.type !== "comment").map((child) => child.text).join(", ")}]`;
+  }
+  const callee = node2.namedChildren.find((child) => child.type !== "type_arguments" && child.type !== "arguments") ?? null;
+  const calleeText = callee?.text?.trim();
+  return calleeText ? `${calleeText}${typeArguments.text}` : typeArguments.text;
+};
+var getInitializerText = (node2, options = {}) => {
+  if (!node2)
+    return null;
+  if ((node2.type === "arrow_function" || node2.type === "function") && !options.includeCallable)
+    return null;
+  const text = node2.text.trim();
+  if ((node2.type === "arrow_function" || node2.type === "function") && text.length > 600)
+    return null;
+  return text.length > 0 ? text : null;
+};
+var inferReturnType = (node2) => {
+  if (!node2)
+    return null;
+  return containsJsx(node2) ? "JSX.Element" : null;
+};
+var containsJsx = (node2) => {
+  if (node2.type.startsWith("jsx_"))
+    return true;
+  return node2.namedChildren.some(containsJsx);
+};
+var resolveTypeBinding = (typeName, importBindings, declarations) => {
+  const localName = typeName.split(".")[0] ?? typeName;
+  const importBinding = importBindings.get(localName);
+  if (importBinding)
+    return importBinding.isExternal;
+  if (declarations.has(localName))
+    return false;
+  return false;
+};
+var appendTypeRelations = (relations, relationType, from, typeText, importBindings, declarations, line) => {
+  for (const typeName of referencedTypeNames(typeText)) {
+    relations.push(createRelation(relationType, from, typeName, resolveTypeBinding(typeName, importBindings, declarations), line));
+  }
+};
+var classifyVariable = (name, filePath) => {
+  if ((filePath.endsWith(".tsx") || filePath.endsWith(".jsx")) && /^[A-Z]/.test(name)) {
+    return "component" /* Component */;
+  }
+  return "variable" /* Variable */;
+};
+var collectParams = (node2) => {
+  if (!node2)
+    return [];
+  return node2.namedChildren.map((child) => {
+    const wrapper = child;
+    const target = child.type === "required_parameter" || child.type === "optional_parameter" ? child.namedChildren[0] ?? child : child;
+    const nameNode = target.childForFieldName("name") ?? target.namedChildren.find((candidate) => candidate.type === "identifier" || candidate.type === "property_identifier") ?? target.namedChildren[0] ?? target;
+    const typeNode = wrapper.childForFieldName("type") ?? wrapper.namedChildren.find((candidate) => candidate.type === "type_annotation") ?? target.childForFieldName("type") ?? target.namedChildren.find((candidate) => candidate.type === "type_annotation") ?? null;
+    return {
+      name: nameNode.text,
+      type: extractTypeAnnotation(typeNode),
+      optional: wrapper.type === "optional_parameter" || wrapper.children.some((child2) => child2.text === "?"),
+      rest: wrapper.text.trimStart().startsWith("..."),
+      ...wrapper.childForFieldName("value") === null ? {} : { defaultValue: wrapper.childForFieldName("value").text }
+    };
+  });
+};
+var collectMembers = (node2, declarations, importBindings, ownerName, relations) => {
+  if (!node2)
+    return;
+  const members = [];
+  for (const child of node2.namedChildren) {
+    if (child.type === "public_field_definition" || child.type === "property_signature") {
+      const nameNode = child.childForFieldName("name") ?? child.namedChildren.find((candidate) => candidate.type === "property_identifier" || candidate.type === "identifier");
+      if (!nameNode)
+        continue;
+      const typeNode = child.childForFieldName("type") ?? child.namedChildren.find((candidate) => candidate.type === "type_annotation") ?? null;
+      const typeAnnotation = extractTypeAnnotation(typeNode);
+      const propDoc = extractJSDoc(child);
+      members.push({
+        name: nameNode.text,
+        kind: "prop" /* Prop */,
+        visibility: "internal" /* Internal */,
+        file: "",
+        line: getLine(child),
+        endLine: getEndLine(child),
+        optional: child.children.some((token) => token.text === "?"),
+        readonly: child.children.some((token) => token.text === "readonly"),
+        ...typeAnnotation ? { typeAnnotation } : {},
+        ...propDoc ? { doc: propDoc } : {}
+      });
+      appendTypeRelations(relations, "of_type" /* OfType */, ownerName, typeAnnotation, importBindings, declarations, getLine(child));
+      continue;
+    }
+    const indexMember = indexSignatureMember(child);
+    if (indexMember) {
+      members.push(indexMember.info);
+      appendTypeRelations(relations, "of_type" /* OfType */, ownerName, indexMember.typeAnnotation, importBindings, declarations, getLine(child));
+      continue;
+    }
+    if (child.type === "method_definition" || child.type === "method_signature") {
+      const nameNode = child.childForFieldName("name") ?? child.namedChildren.find((candidate) => candidate.type === "property_identifier" || candidate.type === "identifier");
+      if (!nameNode)
+        continue;
+      const paramsNode = child.childForFieldName("parameters") ?? child.namedChildren.find((candidate) => candidate.type === "formal_parameters") ?? null;
+      const params = collectParams(paramsNode);
+      const returnType = getReturnType(child);
+      const methodDoc = extractJSDoc(child);
+      members.push({
+        name: nameNode.text,
+        kind: "method" /* Method */,
+        visibility: "internal" /* Internal */,
+        file: "",
+        line: getLine(child),
+        endLine: getEndLine(child),
+        ...params.length > 0 ? { params } : {},
+        ...returnType ? { returnType } : {},
+        ...methodDoc ? { doc: methodDoc } : {}
+      });
+      for (const param of params) {
+        appendTypeRelations(relations, "param_type" /* ParamType */, ownerName, param.type, importBindings, declarations, getLine(child));
+      }
+      appendTypeRelations(relations, "return_type" /* ReturnType */, ownerName, returnType, importBindings, declarations, getLine(child));
+    }
+  }
+  return members.length > 0 ? members : undefined;
+};
+var indexSignatureMember = (node2) => {
+  if (node2.type !== "index_signature")
+    return null;
+  const match = /^\s*(\[[^\]]+\])\s*:?\s*([^;]+)?;?\s*$/u.exec(node2.text);
+  const name = match?.[1]?.trim();
+  const typeAnnotation = match?.[2]?.trim();
+  if (!name)
+    return null;
+  const propDoc = extractJSDoc(node2);
+  return {
+    info: {
+      name,
+      kind: "prop" /* Prop */,
+      visibility: "internal" /* Internal */,
+      file: "",
+      line: getLine(node2),
+      endLine: getEndLine(node2),
+      ...typeAnnotation ? { typeAnnotation } : {},
+      ...propDoc ? { doc: propDoc } : {}
+    },
+    typeAnnotation
+  };
+};
+var collectEnumValues = (node2) => {
+  const body = node2.namedChildren.find((child) => child.type === "enum_body") ?? null;
+  if (!body)
+    return;
+  const values = [];
+  for (const member of body.namedChildren.filter((child) => child.type === "enum_assignment" || child.type === "property_identifier")) {
+    if (member.type === "property_identifier") {
+      values.push(member.text);
+      continue;
+    }
+    const name = member.childForFieldName("name")?.text ?? member.namedChildren[0]?.text;
+    if (!name)
+      continue;
+    const valueNode = member.childForFieldName("value") ?? member.namedChildren.find((child) => child !== member.childForFieldName("name")) ?? null;
+    const rawValue = valueNode?.text.replace(/^['"]|['"]$/gu, "");
+    values.push(rawValue ? `${name} = ${rawValue}` : name);
+  }
+  return values.length > 0 ? values : undefined;
+};
+var extractUnionLiteralValues = (typeNode) => {
+  if (!typeNode)
+    return;
+  if (typeNode.type === "literal_type") {
+    const text = typeNode.text.replace(/^['"]|['"]$/g, "");
+    return text ? [text] : undefined;
+  }
+  if (typeNode.type === "union_type") {
+    const values = [];
+    for (const child of typeNode.namedChildren) {
+      if (child.type === "literal_type") {
+        const text = child.text.replace(/^['"]|['"]$/g, "");
+        if (text)
+          values.push(text);
+      } else if (child.type === "union_type") {
+        const nested = extractUnionLiteralValues(child);
+        if (!nested)
+          return;
+        values.push(...nested);
+      } else {
+        return;
+      }
+    }
+    return values.length > 0 ? values : undefined;
+  }
+  return;
+};
+var findObjectTypeNodes = (node2) => {
+  if (!node2)
+    return [];
+  if (node2.type === "object_type")
+    return [node2];
+  if (node2.type === "intersection_type" || node2.type === "union_type") {
+    return node2.namedChildren.flatMap(findObjectTypeNodes);
+  }
+  if (node2.type === "parenthesized_type" && node2.namedChildCount > 0) {
+    return findObjectTypeNodes(node2.namedChildren[0]);
+  }
+  return [];
+};
+
+// src/runtimeRegistrations.ts
+import ts4 from "typescript";
+function runtimeRegistrations(source) {
+  const imports = new Map;
+  const receivers = new Map;
+  const middleware = new Map;
+  const result = [];
+  const supported = new Set(["express", "fastify", "hono", "node-cron", "node:events", "events"]);
+  for (const statement of source.statements) {
+    if (!ts4.isImportDeclaration(statement) || !ts4.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const module = statement.moduleSpecifier.text;
+    if (!supported.has(module))
+      continue;
+    const clause = statement.importClause;
+    if (clause?.name !== undefined)
+      imports.set(clause.name.text, module);
+    if (clause?.namedBindings !== undefined) {
+      if (ts4.isNamespaceImport(clause.namedBindings))
+        imports.set(clause.namedBindings.name.text, module);
+      else
+        for (const item of clause.namedBindings.elements)
+          imports.set(item.name.text, module);
+    }
+  }
+  const rootName = (node2) => ts4.isIdentifier(node2) ? node2.text : ts4.isPropertyAccessExpression(node2) ? rootName(node2.expression) : undefined;
+  const visit = (node2) => {
+    if (ts4.isVariableDeclaration(node2) && ts4.isIdentifier(node2.name) && node2.initializer !== undefined && (ts4.isCallExpression(node2.initializer) || ts4.isNewExpression(node2.initializer))) {
+      const root = rootName(node2.initializer.expression);
+      const module = root === undefined ? undefined : imports.get(root);
+      if (module !== undefined)
+        receivers.set(node2.name.text, module);
+    }
+    if (ts4.isCallExpression(node2) && ts4.isPropertyAccessExpression(node2.expression)) {
+      const receiver = node2.expression.expression.getText(source);
+      const module = receivers.get(receiver) ?? imports.get(receiver);
+      const operation = node2.expression.name.text;
+      if (module !== undefined) {
+        const args = node2.arguments;
+        const http = ["express", "fastify", "hono"].includes(module);
+        if (http && operation === "use") {
+          middleware.set(receiver, [...middleware.get(receiver) ?? [], ...args.map((arg) => arg.getText(source))]);
+        }
+        const kind = http && ["get", "post", "put", "patch", "delete", "head", "options", "all"].includes(operation) ? "http" : module === "node-cron" && operation === "schedule" ? "schedule" : ["events", "node:events"].includes(module) && ["on", "once"].includes(operation) ? "event" : undefined;
+        const first = args[0];
+        if (kind !== undefined && first !== undefined && ts4.isStringLiteralLike(first) && args.length >= 2) {
+          const handler = args.at(-1).getText(source);
+          const line = source.getLineAndCharacterOfPosition(node2.getStart()).line + 1;
+          result.push({
+            name: `${kind === "http" ? operation.toUpperCase() : kind} ${first.text}`,
+            kind: kind === "http" ? "endpoint" /* Endpoint */ : "process" /* Process */,
+            visibility: "exported" /* Exported */,
+            file: source.fileName.replace(/^\//u, ""),
+            line,
+            endLine: source.getLineAndCharacterOfPosition(node2.end).line + 1,
+            signature: `${operation} ${first.text} → ${handler}`,
+            registration: {
+              kind,
+              key: first.text,
+              handler,
+              ...kind === "http" ? { method: operation.toUpperCase() } : {},
+              middleware: [...middleware.get(receiver) ?? [], ...args.slice(1, -1).map((arg) => arg.getText(source))]
+            }
+          });
+        }
+      }
+    }
+    ts4.forEachChild(node2, visit);
+  };
+  visit(source);
+  return result;
+}
+
+// src/publicContracts.ts
+var format = ts5.TypeFormatFlags.NoTruncation | ts5.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+function declarationAt(source, symbol) {
+  const candidates = [];
+  const visit = (node2) => {
+    const line = source.getLineAndCharacterOfPosition(node2.getStart(source)).line + 1;
+    if (line > symbol.endLine)
+      return;
+    if (line === symbol.line && (ts5.isFunctionDeclaration(node2) || ts5.isVariableDeclaration(node2) || ts5.isInterfaceDeclaration(node2) || ts5.isTypeAliasDeclaration(node2) || ts5.isClassDeclaration(node2))) {
+      candidates.push(node2);
+    }
+    ts5.forEachChild(node2, visit);
+  };
+  visit(source);
+  return candidates.find((node2) => ("name" in node2) && node2.name?.getText(source) === symbol.name) ?? (candidates.length === 1 ? candidates[0] : undefined);
+}
+function declaredObjectTypes(node2, checker, seen = new Set) {
+  if (seen.has(node2))
+    return [];
+  seen.add(node2);
+  if (ts5.isTypeAliasDeclaration(node2))
+    return declaredObjectTypes(node2.type, checker, seen);
+  if (ts5.isParenthesizedTypeNode(node2))
+    return declaredObjectTypes(node2.type, checker, seen);
+  if (ts5.isIntersectionTypeNode(node2))
+    return node2.types.flatMap((type) => declaredObjectTypes(type, checker, seen));
+  if (ts5.isTypeReferenceNode(node2) && !node2.typeArguments?.length) {
+    let symbol = checker.getSymbolAtLocation(node2.typeName);
+    if (symbol !== undefined && (symbol.flags & ts5.SymbolFlags.Alias) !== 0)
+      symbol = checker.getAliasedSymbol(symbol);
+    return (symbol?.declarations ?? []).flatMap((declaration) => declaredObjectTypes(declaration, checker, seen));
+  }
+  return ts5.isTypeLiteralNode(node2) || ts5.isInterfaceDeclaration(node2) ? [node2] : [];
+}
+function memberTypeText(checker, type, member, annotation) {
+  const text = checker.typeToString(type, member, format);
+  if (annotation === undefined)
+    return { text, complete: (type.flags & (ts5.TypeFlags.Any | ts5.TypeFlags.Unknown)) === 0 };
+  if (annotation.kind === ts5.SyntaxKind.AnyKeyword || annotation.kind === ts5.SyntaxKind.UnknownKeyword) {
+    return { text: annotation.getText(), complete: true };
+  }
+  let incomplete = (type.flags & (ts5.TypeFlags.Any | ts5.TypeFlags.Unknown)) !== 0 || text === "{}" && !ts5.isTypeLiteralNode(annotation);
+  const visit = (node2) => {
+    if (ts5.isArrayTypeNode(node2) || ts5.isTupleTypeNode(node2) || ts5.isTypeReferenceNode(node2)) {
+      const resolved = checker.getTypeFromTypeNode(node2);
+      const rendered = checker.typeToString(resolved, node2, format);
+      if ((resolved.flags & (ts5.TypeFlags.Any | ts5.TypeFlags.Unknown)) !== 0 || ts5.isArrayTypeNode(node2) && rendered === "{}")
+        incomplete = true;
+    }
+    ts5.forEachChild(node2, visit);
+  };
+  visit(annotation);
+  return { text: incomplete ? annotation.getText() : text, complete: !incomplete };
+}
+function callable(node2) {
+  if (ts5.isFunctionDeclaration(node2))
+    return node2;
+  if (!ts5.isVariableDeclaration(node2))
+    return;
+  let value = node2.initializer;
+  if (value !== undefined && ts5.isCallExpression(value)) {
+    value = value.arguments.find((argument) => ts5.isArrowFunction(argument) || ts5.isFunctionExpression(argument));
+  }
+  return value !== undefined && (ts5.isArrowFunction(value) || ts5.isFunctionExpression(value)) ? value : undefined;
+}
+async function enrichPublicContracts(input) {
+  const sources = new Map;
+  for (const path2 of input.paths) {
+    const source = await input.fs.readFile(path2);
+    const absolute = posix3.resolve("/", path2);
+    sources.set(absolute, ts5.createSourceFile(absolute, source, ts5.ScriptTarget.Latest, true));
+  }
+  const options = {
+    noLib: true,
+    skipLibCheck: true,
+    allowJs: true,
+    jsx: ts5.JsxEmit.Preserve,
+    moduleResolution: ts5.ModuleResolutionKind.Node10,
+    baseUrl: "/",
+    paths: Object.fromEntries((input.resolver?.mappings ?? []).map((mapping) => [mapping.pattern, mapping.targets.map((target) => posix3.resolve("/", target))]))
+  };
+  const host = {
+    getSourceFile: (path2) => sources.get(posix3.resolve("/", path2)),
+    getDefaultLibFileName: () => "",
+    writeFile: () => {},
+    getCurrentDirectory: () => "/",
+    getDirectories: () => [],
+    fileExists: (path2) => sources.has(posix3.resolve("/", path2)),
+    readFile: (path2) => sources.get(posix3.resolve("/", path2))?.text,
+    getCanonicalFileName: (path2) => posix3.resolve("/", path2),
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => `
+`
+  };
+  for (const source of sources.values())
+    input.symbols.push(...runtimeRegistrations(source), ...federationContracts(source));
+  if (!input.symbols.some((symbol) => symbol.visibility === "exported" /* Exported */))
+    return;
+  const program = ts5.createProgram([...sources.keys()], options, host);
+  const checker = program.getTypeChecker();
+  const diagnosticsByFile = new Map;
+  for (const symbol of input.symbols) {
+    if (symbol.visibility !== "exported" /* Exported */)
+      continue;
+    const source = sources.get(posix3.resolve("/", symbol.file));
+    if (source === undefined)
+      continue;
+    const declaration = declarationAt(source, symbol);
+    if (declaration === undefined)
+      continue;
+    symbol.contractResolution = "declaration-only";
+    const fn = callable(declaration);
+    if (fn !== undefined) {
+      symbol.params = fn.parameters.map((parameter) => ({
+        name: parameter.name.getText(source),
+        type: parameter.type?.getText(source) ?? checker.typeToString(checker.getTypeAtLocation(parameter), parameter, format),
+        optional: parameter.questionToken !== undefined || parameter.initializer !== undefined,
+        rest: parameter.dotDotDotToken !== undefined,
+        ...parameter.initializer === undefined ? {} : { defaultValue: parameter.initializer.getText(source) }
+      }));
+      if (fn.typeParameters !== undefined)
+        symbol.typeParameters = `<${fn.typeParameters.map((item) => item.getText(source)).join(", ")}>`;
+    }
+    const valueType = checker.getTypeAtLocation(declaration);
+    const signatures = valueType.getCallSignatures();
+    const declaredSignatures = signatures.flatMap((signature) => {
+      const declared = signature.getDeclaration();
+      if (declared === undefined || !sources.has(declared.getSourceFile().fileName))
+        return [];
+      const body = "body" in declared ? declared.body : undefined;
+      return [declared.getSourceFile().text.slice(declared.getStart(), body?.pos ?? declared.getEnd()).trim().replace(/;$/u, "")];
+    });
+    if (declaredSignatures.length > 1)
+      symbol.overloads = declaredSignatures;
+    let contractType;
+    let localProps;
+    if (symbol.kind === "component" /* Component */) {
+      const parameter = signatures[0]?.parameters[0];
+      if (parameter !== undefined) {
+        contractType = checker.getTypeOfSymbolAtLocation(parameter, declaration);
+        symbol.propsType = checker.typeToString(contractType, declaration, format);
+      }
+      const annotation = fn?.parameters[0]?.type ?? (ts5.isVariableDeclaration(declaration) ? componentPropsNode(declaration.type) : undefined);
+      if (annotation !== undefined) {
+        contractType = checker.getTypeFromTypeNode(annotation);
+        symbol.propsType = annotation.getText(source);
+        localProps = componentLocalPropsNode(annotation, checker);
+      }
+    } else if (ts5.isInterfaceDeclaration(declaration) || ts5.isTypeAliasDeclaration(declaration)) {
+      contractType = checker.getTypeAtLocation(declaration);
+    }
+    if (contractType === undefined)
+      continue;
+    const unresolved = (contractType.flags & (ts5.TypeFlags.Any | ts5.TypeFlags.Unknown)) !== 0;
+    const localType = unresolved && localProps !== undefined ? checker.getTypeFromTypeNode(localProps) : undefined;
+    const knownType = localType ?? contractType;
+    const properties = (knownType.flags & (ts5.TypeFlags.Any | ts5.TypeFlags.Unknown)) !== 0 ? declaredObjectTypes(localProps ?? declaration, checker).flatMap((node2) => checker.getPropertiesOfType(checker.getTypeAtLocation(node2))) : checker.getPropertiesOfType(knownType);
+    if (properties.length === 0)
+      continue;
+    if (symbol.kind === "component" /* Component */ && symbol.propsType !== undefined && input.relations !== undefined) {
+      const typeSymbol = knownType.aliasSymbol ?? knownType.getSymbol();
+      const declaration2 = typeSymbol?.declarations?.[0];
+      if (typeSymbol !== undefined && declaration2 !== undefined)
+        input.relations.push({ ...createRelation("of_type" /* OfType */, symbol.name, typeSymbol.name, !sources.has(declaration2.getSourceFile().fileName), symbol.line), file: symbol.file });
+    }
+    const pattern = fn?.parameters[0]?.name;
+    const defaults = pattern === undefined ? {} : componentDefaultsFromBinding(pattern, source);
+    const members = [];
+    let completeMembers = true;
+    for (const property of properties) {
+      const member = property.valueDeclaration ?? property.declarations?.[0];
+      if (member === undefined || !sources.has(member.getSourceFile().fileName))
+        continue;
+      const memberSource = member.getSourceFile();
+      const modifiers = ts5.canHaveModifiers(member) ? ts5.getModifiers(member) : undefined;
+      const propertyType = checker.getTypeOfSymbolAtLocation(property, member);
+      const annotation = "type" in member ? member.type : undefined;
+      const documentedDefault = ts5.getJSDocTags(member).find((tag) => tag.tagName.text === "default" || tag.tagName.text === "defaultValue");
+      const defaultComment = documentedDefault?.comment;
+      const defaultText = typeof defaultComment === "string" ? defaultComment.trim() : defaultComment === undefined ? undefined : defaultComment.map((part) => part.getText(memberSource)).join("").trim();
+      const defaultValue = (Object.hasOwn(defaults, property.name) ? defaults[property.name] : undefined) ?? (defaultText || undefined);
+      const hidden = ts5.getJSDocTags(member).some((tag) => ["internal", "private"].includes(tag.tagName.text)) || modifiers?.some((modifier) => modifier.kind === ts5.SyntaxKind.PrivateKeyword || modifier.kind === ts5.SyntaxKind.ProtectedKeyword);
+      if (hidden)
+        continue;
+      const renderedType = memberTypeText(checker, propertyType, member, annotation);
+      completeMembers &&= renderedType.complete;
+      members.push({
+        name: property.name,
+        kind: "prop" /* Prop */,
+        visibility: "exported" /* Exported */,
+        file: posix3.relative("/", memberSource.fileName),
+        line: memberSource.getLineAndCharacterOfPosition(member.getStart()).line + 1,
+        endLine: memberSource.getLineAndCharacterOfPosition(member.getEnd()).line + 1,
+        optional: (property.flags & ts5.SymbolFlags.Optional) !== 0,
+        ...defaultValue === undefined ? {} : { defaultValue },
+        readonly: modifiers?.some((modifier) => modifier.kind === ts5.SyntaxKind.ReadonlyKeyword) ?? false,
+        typeAnnotation: renderedType.text,
+        doc: ts5.displayPartsToString(property.getDocumentationComment(checker))
+      });
+    }
+    if (properties.length > 0) {
+      symbol.members = members;
+      let diagnostics = diagnosticsByFile.get(source.fileName);
+      if (diagnostics === undefined) {
+        diagnostics = program.getSemanticDiagnostics(source);
+        diagnosticsByFile.set(source.fileName, diagnostics);
+      }
+      symbol.contractResolution = !unresolved && completeMembers && diagnostics.length === 0 ? "resolved" : "declaration-only";
+    }
+  }
+}
+
+// ../extract/src/types.ts
+var symbolKindSchema2 = exports_external.enum(Object.values(SymbolKind));
+var visibilitySchema2 = exports_external.enum(Object.values(Visibility));
+var relationTypeSchema = exports_external.enum([
+  "imports" /* Imports */,
+  "imports_type" /* ImportsType */,
+  "calls" /* Calls */,
+  "extends" /* Extends */,
+  "implements" /* Implements */,
+  "param_type" /* ParamType */,
+  "return_type" /* ReturnType */,
+  "of_type" /* OfType */,
+  "depends_on" /* DependsOn */,
+  "contains" /* Contains */
+]);
+var relationSourceSchema = exports_external.enum([
+  "ast" /* Ast */,
+  "doc" /* Doc */,
+  "manual" /* Manual */
+]);
+var packageKindSchema2 = exports_external.enum(Object.values(PackageKind));
+var symbolParamSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  type: exports_external.string().min(1).nullable(),
+  optional: exports_external.boolean().optional(),
+  rest: exports_external.boolean().optional(),
+  defaultValue: exports_external.string().optional()
+});
+var registrationSchema = exports_external.object({
+  kind: exports_external.enum(["http", "schedule", "event"]),
+  key: exports_external.string(),
+  handler: exports_external.string(),
+  method: exports_external.string().optional(),
+  middleware: exports_external.array(exports_external.string())
+});
+var symbolInfoSchema = exports_external.lazy(() => exports_external.object({
+  name: exports_external.string().min(1),
+  kind: symbolKindSchema2,
+  visibility: visibilitySchema2,
+  file: exports_external.string().min(1),
+  line: exports_external.number().int().positive(),
+  endLine: exports_external.number().int().positive(),
+  members: exports_external.array(symbolInfoSchema).optional(),
+  params: exports_external.array(symbolParamSchema).optional(),
+  optional: exports_external.boolean().optional(),
+  readonly: exports_external.boolean().optional(),
+  defaultValue: exports_external.string().optional(),
+  typeParameters: exports_external.string().optional(),
+  overloads: exports_external.array(exports_external.string()).optional(),
+  publicEntrypoints: exports_external.array(exports_external.string()).optional(),
+  contractResolution: exports_external.enum(["resolved", "declaration-only"]).optional(),
+  registration: registrationSchema.optional(),
+  returnType: exports_external.string().min(1).nullable().optional(),
+  typeAnnotation: exports_external.string().min(1).nullable().optional(),
+  extends: exports_external.string().min(1).nullable().optional(),
+  implements: exports_external.array(exports_external.string().min(1)).optional(),
+  doc: exports_external.string().nullable().optional(),
+  propsType: exports_external.string().min(1).nullable().optional(),
+  unionValues: exports_external.array(exports_external.string()).optional(),
+  initializer: exports_external.string().min(1).nullable().optional(),
+  signature: exports_external.string().min(1).nullable().optional()
+}));
+var relationInfoSchema = exports_external.object({
+  type: relationTypeSchema,
+  from: exports_external.string().min(1),
+  to: exports_external.string().min(1),
+  file: exports_external.string().min(1).optional(),
+  isExternal: exports_external.boolean(),
+  grounding: groundingSchema,
+  confidence: exports_external.number().min(0).max(1),
+  source: relationSourceSchema,
+  line: exports_external.number().int().positive().optional()
+});
+var fileInfoSchema = exports_external.object({
+  path: exports_external.string().min(1),
+  language: exports_external.string().min(1),
+  lines: exports_external.number().int().nonnegative()
+});
+var extractionDiagnosticSchema = exports_external.object({
+  code: exports_external.string().min(1),
+  severity: exports_external.enum(["info", "warning", "error"]),
+  file: exports_external.string().min(1),
+  line: exports_external.number().int().positive(),
+  column: exports_external.number().int().positive()
+});
+var extractionCoverageSchema = exports_external.object({
+  tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
+  capabilities: exports_external.array(exports_external.string().min(1)),
+  files: exports_external.array(exports_external.object({
+    path: exports_external.string().min(1),
+    disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
+    diagnosticCodes: exports_external.array(exports_external.string().min(1))
+  })),
+  diagnostics: exports_external.array(extractionDiagnosticSchema)
+});
+var extractionMetaSchema = exports_external.object({
+  extractedAt: exports_external.string().datetime(),
+  pluginId: exports_external.string().min(1),
+  commitHash: exports_external.string().min(1).nullable(),
+  language: exports_external.string().min(1)
+});
+var extractionPackageSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  kind: packageKindSchema2,
+  language: exports_external.string().min(1),
+  version: exports_external.string().min(1).optional()
+});
+var extractionStatsSchema = exports_external.object({
+  files: exports_external.number().int().nonnegative(),
+  lines: exports_external.number().int().nonnegative(),
+  exportedSymbols: exports_external.number().int().nonnegative(),
+  internalSymbols: exports_external.number().int().nonnegative(),
+  relations: exports_external.number().int().nonnegative()
+});
+var extractionResultSchema = exports_external.object({
+  version: exports_external.literal("2"),
+  meta: extractionMetaSchema,
+  package: extractionPackageSchema,
+  files: exports_external.array(fileInfoSchema),
+  symbols: exports_external.array(symbolInfoSchema),
+  relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
+  stats: extractionStatsSchema
+});
+var digestStatsSchema = exports_external.object({
+  files: exports_external.number().int().nonnegative(),
+  lines: exports_external.number().int().nonnegative(),
+  exported_count: exports_external.number().int().nonnegative(),
+  internal_count: exports_external.number().int().nonnegative(),
+  relations: exports_external.number().int().nonnegative()
+});
+var digestDataSchema = exports_external.object({
+  version: exports_external.literal("2"),
+  meta: extractionMetaSchema,
+  package: extractionPackageSchema,
+  files: exports_external.array(fileInfoSchema),
+  symbols: exports_external.array(symbolInfoSchema),
+  relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
+  stats: digestStatsSchema
+});
+var symbolDiffSchema = exports_external.object({
+  added: exports_external.array(exports_external.string().min(1)),
+  removed: exports_external.array(exports_external.string().min(1))
+});
+// ../extract/src/protocol.ts
+var packageKindSchema3 = exports_external.enum(Object.values(PackageKind));
+var manifestTypeSchema = exports_external.enum([
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml"
+]);
+var entryFileSchema = exports_external.object({
+  path: exports_external.string().min(1),
+  subpath: exports_external.string().min(1),
+  type: exports_external.enum(["library", "cli", "service", "webapp"])
+});
+var manifestInfoSchema = exports_external.object({
+  type: manifestTypeSchema,
+  path: exports_external.string().min(1),
+  content: exports_external.record(exports_external.unknown())
+});
+var sourceInfoSchema = exports_external.object({
+  path: exports_external.string().min(1),
+  manifests: exports_external.array(manifestInfoSchema),
+  language: exports_external.string().min(1).optional()
+});
+var entryDetectionResultSchema = exports_external.lazy(() => exports_external.object({
+  package: exports_external.object({
+    name: exports_external.string().min(1),
+    kind: packageKindSchema3,
+    language: exports_external.string().min(1),
+    version: exports_external.string().min(1).optional()
+  }),
+  entries: exports_external.array(entryFileSchema),
+  subPackages: exports_external.array(entryDetectionResultSchema).optional()
+}));
+var patternDetectionResultSchema = exports_external.object({
+  endpoints: exports_external.array(exports_external.object({
+    handler: exports_external.string().min(1),
+    method: exports_external.string().min(1),
+    path: exports_external.string().min(1),
+    file: exports_external.string().min(1),
+    line: exports_external.number().int().positive()
+  })).optional(),
+  implicitDeps: exports_external.array(exports_external.object({
+    verb: exports_external.enum(["produce", "consume", "depends_on", "serve"]),
+    target: exports_external.string().min(1),
+    file: exports_external.string().min(1),
+    line: exports_external.number().int().positive()
+  })).optional(),
+  configRefs: exports_external.array(exports_external.object({
+    key: exports_external.string().min(1),
+    file: exports_external.string().min(1),
+    line: exports_external.number().int().positive()
+  })).optional()
+});
+// ../extract/src/registry.ts
+var MANIFEST_LANGUAGE_CANDIDATES = {
+  "package.json": ["typescript", "tsx", "javascript", "jsx"],
+  "pyproject.toml": ["python"],
+  "Cargo.toml": ["rust"],
+  "go.mod": ["go"],
+  "pom.xml": ["java"]
+};
+
+class ExtractionPluginRegistry {
+  #plugins = [];
+  register(plugin) {
+    this.#plugins.push(plugin);
+  }
+  resolve(source) {
+    const declaredLanguage = source.language?.toLowerCase();
+    const manifestLanguages = new Set(source.manifests.flatMap((manifest) => MANIFEST_LANGUAGE_CANDIDATES[manifest.type] ?? []));
+    const candidates = this.#plugins.filter((plugin) => {
+      const pluginLanguages = plugin.languages.map((language) => language.toLowerCase());
+      if (declaredLanguage) {
+        return pluginLanguages.includes(declaredLanguage);
+      }
+      if (manifestLanguages.size === 0) {
+        return true;
+      }
+      return pluginLanguages.some((language) => manifestLanguages.has(language));
+    });
+    for (const plugin of candidates) {
+      if (plugin.canHandle(source)) {
+        return plugin;
+      }
+    }
+    return null;
+  }
+  list() {
+    return [...this.#plugins];
+  }
+}
+// ../extract/src/scanner.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var SUPPORTED_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
 var MANIFEST_FILES = [
   "package.json",
   "pyproject.toml",
@@ -12860,6 +13634,8 @@ function semanticExtractionPayload(extraction) {
   };
 }
 function relationSourceFile(relation, symbols, filePaths) {
+  if (relation.file !== undefined)
+    return filePaths.has(relation.file) ? relation.file : null;
   if (filePaths.has(relation.from))
     return relation.from;
   const candidates = symbols.filter((symbol) => symbol.name === relation.from);
@@ -13700,27 +14476,29 @@ var parseFile = async (source, isTsx) => {
   }
 };
 // src/commonJsModule.ts
-import ts2 from "typescript";
+import ts7 from "typescript";
 
 // src/typescriptAst.ts
-import ts from "typescript";
+import ts6 from "typescript";
 var scriptKind = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".tsx"))
-    return ts.ScriptKind.TSX;
+    return ts6.ScriptKind.TSX;
   if (lower.endsWith(".jsx"))
-    return ts.ScriptKind.JSX;
+    return ts6.ScriptKind.JSX;
   if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs")) {
-    return ts.ScriptKind.JS;
+    return ts6.ScriptKind.JS;
   }
-  return ts.ScriptKind.TS;
+  return ts6.ScriptKind.TS;
 };
-var createEcmaScriptSourceFile = (source, filePath) => ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, scriptKind(filePath));
+var createEcmaScriptSourceFile = (source, filePath) => ts6.createSourceFile(filePath, source, ts6.ScriptTarget.Latest, true, scriptKind(filePath));
 var treeSitterCompatibleJsxSource = (sourceFile, source) => {
+  if (!source.includes("&"))
+    return source;
   const characters = source.split("");
   let changed = false;
   const visit2 = (node2) => {
-    const jsxPresentationLiteral = ts.isJsxText(node2) || ts.isStringLiteral(node2) && ts.isJsxAttribute(node2.parent);
+    const jsxPresentationLiteral = ts6.isJsxText(node2) || ts6.isStringLiteral(node2) && ts6.isJsxAttribute(node2.parent);
     if (jsxPresentationLiteral) {
       for (let index = node2.getStart(sourceFile);index < node2.getEnd(); index += 1) {
         if (characters[index] === "&") {
@@ -13729,7 +14507,7 @@ var treeSitterCompatibleJsxSource = (sourceFile, source) => {
         }
       }
     }
-    ts.forEachChild(node2, visit2);
+    ts6.forEachChild(node2, visit2);
   };
   visit2(sourceFile);
   return changed ? characters.join("") : source;
@@ -13760,25 +14538,25 @@ var nodeLocation = (sourceFile, node2) => {
 var staticStringValue = (node2) => {
   if (!node2)
     return null;
-  if (ts.isStringLiteral(node2) || ts.isNoSubstitutionTemplateLiteral(node2))
+  if (ts6.isStringLiteral(node2) || ts6.isNoSubstitutionTemplateLiteral(node2))
     return node2.text;
   return null;
 };
 
 // src/commonJsModule.ts
-var requireCall = (node2) => ts2.isCallExpression(node2) && ts2.isIdentifier(node2.expression) && node2.expression.text === "require" ? node2 : null;
+var requireCall = (node2) => ts7.isCallExpression(node2) && ts7.isIdentifier(node2.expression) && node2.expression.text === "require" ? node2 : null;
 var requireReference = (node2) => {
   const direct = requireCall(node2);
   if (direct) {
     const source = staticStringValue(direct.arguments[0]);
     return source ? { source, importedName: "*" } : null;
   }
-  if (ts2.isPropertyAccessExpression(node2)) {
+  if (ts7.isPropertyAccessExpression(node2)) {
     const call = requireCall(node2.expression);
     const source = call ? staticStringValue(call.arguments[0]) : null;
     return source ? { source, importedName: node2.name.text } : null;
   }
-  if (ts2.isElementAccessExpression(node2)) {
+  if (ts7.isElementAccessExpression(node2)) {
     const call = requireCall(node2.expression);
     const source = call ? staticStringValue(call.arguments[0]) : null;
     const importedName = staticStringValue(node2.argumentExpression);
@@ -13787,20 +14565,20 @@ var requireReference = (node2) => {
   return null;
 };
 var isModuleExports = (node2) => {
-  if (ts2.isPropertyAccessExpression(node2) && ts2.isIdentifier(node2.expression) && node2.expression.text === "module" && node2.name.text === "exports")
+  if (ts7.isPropertyAccessExpression(node2) && ts7.isIdentifier(node2.expression) && node2.expression.text === "module" && node2.name.text === "exports")
     return true;
-  return ts2.isElementAccessExpression(node2) && ts2.isIdentifier(node2.expression) && node2.expression.text === "module" && staticStringValue(node2.argumentExpression) === "exports";
+  return ts7.isElementAccessExpression(node2) && ts7.isIdentifier(node2.expression) && node2.expression.text === "module" && staticStringValue(node2.argumentExpression) === "exports";
 };
-var isExportsObject = (node2) => ts2.isIdentifier(node2) && node2.text === "exports" || isModuleExports(node2);
+var isExportsObject = (node2) => ts7.isIdentifier(node2) && node2.text === "exports" || isModuleExports(node2);
 var isUnsupportedExportMutationCall = (node2) => {
-  if (ts2.isPropertyAccessExpression(node2.expression) && ts2.isIdentifier(node2.expression.expression) && node2.expression.expression.text === "Object" && ["assign", "defineProperties", "defineProperty"].includes(node2.expression.name.text) && node2.arguments[0] && isExportsObject(node2.arguments[0])) {
+  if (ts7.isPropertyAccessExpression(node2.expression) && ts7.isIdentifier(node2.expression.expression) && node2.expression.expression.text === "Object" && ["assign", "defineProperties", "defineProperty"].includes(node2.expression.name.text) && node2.arguments[0] && isExportsObject(node2.arguments[0])) {
     return !(node2.expression.name.text === "defineProperty" && staticStringValue(node2.arguments[1]) === "__esModule");
   }
-  return ts2.isIdentifier(node2.expression) && ["__createBinding", "__export", "__exportStar"].includes(node2.expression.text) && node2.arguments.some(isExportsObject);
+  return ts7.isIdentifier(node2.expression) && ["__createBinding", "__export", "__exportStar"].includes(node2.expression.text) && node2.arguments.some(isExportsObject);
 };
 var commonJsExportTarget = (node2) => {
-  if (ts2.isPropertyAccessExpression(node2)) {
-    if (ts2.isIdentifier(node2.expression) && node2.expression.text === "exports") {
+  if (ts7.isPropertyAccessExpression(node2)) {
+    if (ts7.isIdentifier(node2.expression) && node2.expression.text === "exports") {
       return { kind: "named", exportedName: node2.name.text };
     }
     if (isModuleExports(node2.expression)) {
@@ -13809,9 +14587,9 @@ var commonJsExportTarget = (node2) => {
     if (isModuleExports(node2))
       return { kind: "whole" };
   }
-  if (ts2.isElementAccessExpression(node2)) {
+  if (ts7.isElementAccessExpression(node2)) {
     const property = staticStringValue(node2.argumentExpression);
-    if (ts2.isIdentifier(node2.expression) && node2.expression.text === "exports" && property) {
+    if (ts7.isIdentifier(node2.expression) && node2.expression.text === "exports" && property) {
       return { kind: "named", exportedName: property };
     }
     if (isModuleExports(node2.expression) && property) {
@@ -13823,7 +14601,7 @@ var commonJsExportTarget = (node2) => {
   return null;
 };
 var localReference = (expression, bindings) => {
-  if (ts2.isIdentifier(expression)) {
+  if (ts7.isIdentifier(expression)) {
     const binding = bindings.get(expression.text);
     if (binding) {
       return {
@@ -13833,7 +14611,7 @@ var localReference = (expression, bindings) => {
     }
     return { localName: expression.text };
   }
-  if (ts2.isPropertyAccessExpression(expression) && ts2.isIdentifier(expression.expression)) {
+  if (ts7.isPropertyAccessExpression(expression) && ts7.isIdentifier(expression.expression)) {
     const binding = bindings.get(expression.expression.text);
     if (binding)
       return { source: binding.source, importedName: expression.name.text };
@@ -13843,7 +14621,7 @@ var localReference = (expression, bindings) => {
 };
 var syntheticDeclaration = (name, expression, sourceFile) => {
   const location = nodeLocation(sourceFile, expression);
-  if (ts2.isFunctionExpression(expression) || ts2.isArrowFunction(expression)) {
+  if (ts7.isFunctionExpression(expression) || ts7.isArrowFunction(expression)) {
     return {
       name,
       kind: "function",
@@ -13852,10 +14630,10 @@ var syntheticDeclaration = (name, expression, sourceFile) => {
       params: expression.parameters.map((parameter) => parameter.name.getText(sourceFile))
     };
   }
-  if (ts2.isClassExpression(expression)) {
+  if (ts7.isClassExpression(expression)) {
     return { name, kind: "class", line: location.line, endLine: location.endLine, params: [] };
   }
-  if (ts2.isObjectLiteralExpression(expression) || ts2.isArrayLiteralExpression(expression) || ts2.isLiteralExpression(expression)) {
+  if (ts7.isObjectLiteralExpression(expression) || ts7.isArrayLiteralExpression(expression) || ts7.isLiteralExpression(expression)) {
     return { name, kind: "variable", line: location.line, endLine: location.endLine, params: [] };
   }
   return null;
@@ -13889,13 +14667,13 @@ var appendUnsupportedExportDiagnostic = (result, sourceFile, node2) => {
 var collectBindings = (sourceFile) => {
   const bindings = [];
   for (const statement of sourceFile.statements) {
-    if (!ts2.isVariableStatement(statement))
+    if (!ts7.isVariableStatement(statement))
       continue;
     for (const declaration of statement.declarationList.declarations) {
       if (!declaration.initializer)
         continue;
       const line = nodeLocation(sourceFile, declaration).line;
-      if (ts2.isIdentifier(declaration.name)) {
+      if (ts7.isIdentifier(declaration.name)) {
         const reference = requireReference(declaration.initializer);
         if (reference)
           bindings.push({ localName: declaration.name.text, ...reference, line });
@@ -13903,10 +14681,10 @@ var collectBindings = (sourceFile) => {
       }
       const direct = requireCall(declaration.initializer);
       const source = direct ? staticStringValue(direct.arguments[0]) : null;
-      if (!source || !ts2.isObjectBindingPattern(declaration.name))
+      if (!source || !ts7.isObjectBindingPattern(declaration.name))
         continue;
       for (const element of declaration.name.elements) {
-        if (!ts2.isIdentifier(element.name))
+        if (!ts7.isIdentifier(element.name))
           continue;
         const importedName = element.propertyName?.getText(sourceFile) ?? element.name.text;
         bindings.push({ localName: element.name.text, source, importedName, line });
@@ -13918,7 +14696,7 @@ var collectBindings = (sourceFile) => {
 var collectDynamicDiagnostics = (sourceFile) => {
   const diagnostics = [];
   const visit2 = (node2) => {
-    if (ts2.isCallExpression(node2) && ts2.isIdentifier(node2.expression) && node2.expression.text === "require") {
+    if (ts7.isCallExpression(node2) && ts7.isIdentifier(node2.expression) && node2.expression.text === "require") {
       if (staticStringValue(node2.arguments[0]) === null) {
         const location = nodeLocation(sourceFile, node2);
         diagnostics.push({
@@ -13930,7 +14708,7 @@ var collectDynamicDiagnostics = (sourceFile) => {
         });
       }
     }
-    if (ts2.isCallExpression(node2) && isUnsupportedExportMutationCall(node2)) {
+    if (ts7.isCallExpression(node2) && isUnsupportedExportMutationCall(node2)) {
       const location = nodeLocation(sourceFile, node2);
       diagnostics.push({
         code: "unsupported-commonjs-export-form",
@@ -13940,9 +14718,9 @@ var collectDynamicDiagnostics = (sourceFile) => {
         column: location.column
       });
     }
-    if (ts2.isBinaryExpression(node2) && node2.operatorToken.kind === ts2.SyntaxKind.EqualsToken) {
-      if (ts2.isElementAccessExpression(node2.left)) {
-        const isCommonJsTarget = ts2.isIdentifier(node2.left.expression) && node2.left.expression.text === "exports" || isModuleExports(node2.left.expression) || isModuleExports(node2.left);
+    if (ts7.isBinaryExpression(node2) && node2.operatorToken.kind === ts7.SyntaxKind.EqualsToken) {
+      if (ts7.isElementAccessExpression(node2.left)) {
+        const isCommonJsTarget = ts7.isIdentifier(node2.left.expression) && node2.left.expression.text === "exports" || isModuleExports(node2.left.expression) || isModuleExports(node2.left);
         if (isCommonJsTarget && commonJsExportTarget(node2.left) === null) {
           const location = nodeLocation(sourceFile, node2.left);
           diagnostics.push({
@@ -13955,13 +14733,12 @@ var collectDynamicDiagnostics = (sourceFile) => {
         }
       }
     }
-    ts2.forEachChild(node2, visit2);
+    ts7.forEachChild(node2, visit2);
   };
   visit2(sourceFile);
   return diagnostics;
 };
-var analyzeCommonJsModule = (source, filePath) => {
-  const sourceFile = createEcmaScriptSourceFile(source, filePath);
+var analyzeCommonJsModule = (source, filePath, sourceFile = createEcmaScriptSourceFile(source, filePath)) => {
   const bindings = collectBindings(sourceFile);
   const bindingMap = new Map(bindings.map((binding) => [binding.localName, binding]));
   const result = {
@@ -13972,10 +14749,10 @@ var analyzeCommonJsModule = (source, filePath) => {
     diagnostics: collectDynamicDiagnostics(sourceFile)
   };
   for (const statement of sourceFile.statements) {
-    if (!ts2.isExpressionStatement(statement) || !ts2.isBinaryExpression(statement.expression))
+    if (!ts7.isExpressionStatement(statement) || !ts7.isBinaryExpression(statement.expression))
       continue;
     const assignment = statement.expression;
-    if (assignment.operatorToken.kind !== ts2.SyntaxKind.EqualsToken)
+    if (assignment.operatorToken.kind !== ts7.SyntaxKind.EqualsToken)
       continue;
     const target = commonJsExportTarget(assignment.left);
     if (!target)
@@ -13992,14 +14769,14 @@ var analyzeCommonJsModule = (source, filePath) => {
       result.wildcardSources.push(directRequire.source);
       continue;
     }
-    if (ts2.isObjectLiteralExpression(assignment.right)) {
+    if (ts7.isObjectLiteralExpression(assignment.right)) {
       for (const property of assignment.right.properties) {
-        if (ts2.isShorthandPropertyAssignment(property)) {
+        if (ts7.isShorthandPropertyAssignment(property)) {
           pushExport(result, property.name.text, property.name, line, bindingMap, sourceFile);
           continue;
         }
-        if (ts2.isPropertyAssignment(property)) {
-          const name = property.name && (ts2.isIdentifier(property.name) || ts2.isStringLiteral(property.name)) ? property.name.text : null;
+        if (ts7.isPropertyAssignment(property)) {
+          const name = property.name && (ts7.isIdentifier(property.name) || ts7.isStringLiteral(property.name)) ? property.name.text : null;
           if (name) {
             if (!pushExport(result, name, property.initializer, line, bindingMap, sourceFile)) {
               appendUnsupportedExportDiagnostic(result, sourceFile, property.initializer);
@@ -14009,7 +14786,7 @@ var analyzeCommonJsModule = (source, filePath) => {
           }
           continue;
         }
-        if (ts2.isMethodDeclaration(property) && property.name && ts2.isIdentifier(property.name)) {
+        if (ts7.isMethodDeclaration(property) && property.name && ts7.isIdentifier(property.name)) {
           const location = nodeLocation(sourceFile, property);
           result.syntheticDeclarations.push({
             name: property.name.text,
@@ -14029,290 +14806,52 @@ var analyzeCommonJsModule = (source, filePath) => {
       }
       continue;
     }
-    if (ts2.isIdentifier(assignment.right)) {
+    if (ts7.isIdentifier(assignment.right)) {
       const binding = bindingMap.get(assignment.right.text);
       if (binding?.importedName === "*") {
         result.wildcardSources.push(binding.source);
         continue;
       }
-      if (!pushExport(result, assignment.right.text, assignment.right, line, bindingMap, sourceFile)) {
-        appendUnsupportedExportDiagnostic(result, sourceFile, assignment.right);
-      }
-      continue;
-    }
-    if (!pushExport(result, "default", assignment.right, line, bindingMap, sourceFile)) {
-      appendUnsupportedExportDiagnostic(result, sourceFile, assignment.right);
-    }
-  }
-  result.bindings.sort((left, right) => left.localName.localeCompare(right.localName));
-  result.exports.sort((left, right) => left.exportedName.localeCompare(right.exportedName) || left.line - right.line);
-  result.wildcardSources = [...new Set(result.wildcardSources)].sort();
-  result.syntheticDeclarations.sort((left, right) => left.name.localeCompare(right.name));
-  result.diagnostics.sort((left, right) => left.line - right.line || left.column - right.column);
-  return result;
-};
-
-// src/commonJsExportTrace.ts
-var traceCommonJsExports = async (input) => {
-  const traced = [];
-  for (const item of input.analysis.exports) {
-    if (item.localName && input.localDeclarations.has(item.localName)) {
-      traced.push({
-        exportedName: item.exportedName,
-        localName: item.localName,
-        declarationFile: input.filePath
-      });
-      continue;
-    }
-    if (item.source && item.importedName) {
-      traced.push(...await input.traceImported(item.source, item.importedName, item.exportedName));
-    }
-  }
-  for (const source of input.analysis.wildcardSources) {
-    traced.push(...await input.traceWildcard(source));
-  }
-  return traced;
-};
-
-// src/exportTracer.ts
-var DECLARATION_TYPES = new Set([
-  "function_declaration",
-  "class_declaration",
-  "interface_declaration",
-  "type_alias_declaration",
-  "enum_declaration",
-  "lexical_declaration"
-]);
-var stripQuotes = (value) => value.replace(/^['"]/, "").replace(/['"]$/, "");
-var getDeclarationName = (node2) => {
-  if (node2.type === "lexical_declaration") {
-    return node2.namedChildren.filter((child) => child.type === "variable_declarator").map((child) => child.childForFieldName("name")?.text ?? child.namedChildren[0]?.text ?? "").filter(Boolean);
-  }
-  const nameNode = node2.childForFieldName("name") ?? node2.namedChildren.find((child) => child.type === "identifier" || child.type === "type_identifier");
-  return nameNode?.text ? [nameNode.text] : [];
-};
-var collectLocalDeclarations = (root) => {
-  const declarations = new Map;
-  const register = (node2) => {
-    for (const name of getDeclarationName(node2)) {
-      if (!declarations.has(name)) {
-        declarations.set(name, name);
-      }
-    }
-  };
-  for (const child of root.namedChildren) {
-    if (DECLARATION_TYPES.has(child.type)) {
-      register(child);
-      continue;
-    }
-    if (child.type !== "export_statement")
-      continue;
-    const declaration = child.namedChildren.find((node2) => DECLARATION_TYPES.has(node2.type));
-    if (declaration) {
-      register(declaration);
-    }
-  }
-  return declarations;
-};
-var parseExportSpecifier = (node2) => {
-  const identifiers = node2.namedChildren.filter((child) => child.type === "identifier" || child.type === "type_identifier").map((child) => child.text);
-  if (identifiers.length === 0)
-    return null;
-  const localName = identifiers[0];
-  const exportedName = identifiers[1] ?? localName;
-  return { localName, exportedName };
-};
-var parseImportSpecifier = (node2) => {
-  const identifiers = node2.namedChildren.filter((child) => child.type === "identifier" || child.type === "type_identifier").map((child) => child.text);
-  if (identifiers.length === 0)
-    return null;
-  const importedName = identifiers[0];
-  const localName = identifiers[1] ?? importedName;
-  return { importedName, localName };
-};
-var collectImportBindings = (root) => {
-  const bindings = new Map;
-  for (const node2 of root.namedChildren) {
-    if (node2.type !== "import_statement")
-      continue;
-    const stringNode = node2.namedChildren.find((child) => child.type === "string");
-    if (!stringNode)
-      continue;
-    const source = stripQuotes(stringNode.text);
-    const clause = node2.namedChildren.find((child) => child.type === "import_clause");
-    for (const part of clause?.namedChildren ?? []) {
-      if (part.type === "identifier") {
-        bindings.set(part.text, { source, importedName: "default" });
-        continue;
-      }
-      if (part.type !== "named_imports")
-        continue;
-      for (const specifier of part.namedChildren.filter((child) => child.type === "import_specifier")) {
-        const parsed = parseImportSpecifier(specifier);
-        if (parsed) {
-          bindings.set(parsed.localName, { source, importedName: parsed.importedName });
-        }
-      }
-    }
-  }
-  return bindings;
-};
-var uniqueExports = (exportsList) => {
-  const seen = new Set;
-  return exportsList.filter((item) => {
-    const key = `${item.declarationFile}::${item.localName}::${item.exportedName}`;
-    if (seen.has(key))
-      return false;
-    seen.add(key);
-    return true;
-  });
-};
-var traceImportedBinding = async (filePath, binding, exportedName, fs, state) => {
-  const targetPath = await resolveImportSourcePath(filePath, binding.source, fs, state.resolver);
-  if (!targetPath)
-    return [];
-  const traced = await traceFile(targetPath, fs, state);
-  const match = traced.find((item) => item.exportedName === binding.importedName || binding.importedName === "default" && item.exportedName === item.localName);
-  if (!match)
-    return [];
-  return [{
-    exportedName,
-    localName: match.localName,
-    declarationFile: match.declarationFile
-  }];
-};
-var traceFile = async (filePath, fs, state) => {
-  const cached = state.cache.get(filePath);
-  if (cached)
-    return cached;
-  if (state.inFlight.has(filePath))
-    return [];
-  const promise = (async () => {
-    state.inFlight.add(filePath);
-    state.files.add(filePath);
-    const source = await fs.readFile(filePath);
-    const commonJs = analyzeCommonJsModule(source, filePath);
-    if (commonJs.diagnostics.length > 0)
-      return [];
-    const jsxLike = isJsxLikePath(filePath);
-    const parserSource = jsxLike ? treeSitterCompatibleJsxSource(createEcmaScriptSourceFile(source, filePath), source) : source;
-    const tree = await parseFile(parserSource, jsxLike);
-    if (!tree)
-      return [];
-    const root = tree.rootNode;
-    const localDeclarations = collectLocalDeclarations(root);
-    const importBindings = collectImportBindings(root);
-    for (const declaration of commonJs.syntheticDeclarations) {
-      localDeclarations.set(declaration.name, declaration.name);
-    }
-    for (const binding of commonJs.bindings) {
-      importBindings.set(binding.localName, {
-        source: binding.source,
-        importedName: binding.importedName
-      });
-    }
-    const exportsList = [];
-    for (const node2 of root.namedChildren) {
-      if (node2.type !== "export_statement")
-        continue;
-      const stringNode = node2.namedChildren.find((child) => child.type === "string");
-      const exportClause = node2.namedChildren.find((child) => child.type === "export_clause");
-      const declaration = node2.namedChildren.find((child) => DECLARATION_TYPES.has(child.type));
-      if (declaration) {
-        for (const name of getDeclarationName(declaration)) {
-          exportsList.push({ exportedName: name, localName: name, declarationFile: filePath });
-        }
-        continue;
-      }
-      if (node2.text.startsWith("export default ")) {
-        const identifier = node2.namedChildren.find((child) => child.type === "identifier" || child.type === "type_identifier");
-        if (identifier && localDeclarations.has(identifier.text)) {
-          exportsList.push({
-            exportedName: identifier.text,
-            localName: identifier.text,
-            declarationFile: filePath
-          });
-        }
-        continue;
-      }
-      if (!exportClause) {
-        if (stringNode && node2.text.startsWith("export *")) {
-          const targetPath2 = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs, state.resolver);
-          if (targetPath2) {
-            exportsList.push(...await traceFile(targetPath2, fs, state));
-          }
-        }
-        continue;
-      }
-      if (!stringNode) {
-        for (const specifier of exportClause.namedChildren.filter((child) => child.type === "export_specifier")) {
-          const parsed = parseExportSpecifier(specifier);
-          if (!parsed)
-            continue;
-          if (localDeclarations.has(parsed.localName)) {
-            exportsList.push({
-              exportedName: parsed.exportedName,
-              localName: parsed.localName,
-              declarationFile: filePath
-            });
-            continue;
-          }
-          const importBinding = importBindings.get(parsed.localName);
-          if (importBinding) {
-            exportsList.push(...await traceImportedBinding(filePath, importBinding, parsed.exportedName, fs, state));
-          }
-        }
-        continue;
-      }
-      const targetPath = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs, state.resolver);
-      if (!targetPath)
-        continue;
-      const traced = await traceFile(targetPath, fs, state);
-      for (const specifier of exportClause.namedChildren.filter((child) => child.type === "export_specifier")) {
-        const parsed = parseExportSpecifier(specifier);
-        if (!parsed)
-          continue;
-        const match = traced.find((item) => item.exportedName === parsed.localName);
-        if (!match)
-          continue;
-        exportsList.push({
-          exportedName: parsed.exportedName,
-          localName: match.localName,
-          declarationFile: match.declarationFile
-        });
+      if (!pushExport(result, assignment.right.text, assignment.right, line, bindingMap, sourceFile)) {
+        appendUnsupportedExportDiagnostic(result, sourceFile, assignment.right);
       }
+      continue;
     }
-    exportsList.push(...await traceCommonJsExports({
-      analysis: commonJs,
-      filePath,
-      localDeclarations,
-      traceImported: (source2, importedName, exportedName) => traceImportedBinding(filePath, { source: source2, importedName }, exportedName, fs, state),
-      traceWildcard: async (source2) => {
-        const targetPath = await resolveImportSourcePath(filePath, source2, fs, state.resolver);
-        return targetPath ? traceFile(targetPath, fs, state) : [];
-      }
-    }));
-    state.inFlight.delete(filePath);
-    return uniqueExports(exportsList);
-  })();
-  state.cache.set(filePath, promise);
-  return promise;
+    if (!pushExport(result, "default", assignment.right, line, bindingMap, sourceFile)) {
+      appendUnsupportedExportDiagnostic(result, sourceFile, assignment.right);
+    }
+  }
+  result.bindings.sort((left, right) => left.localName.localeCompare(right.localName));
+  result.exports.sort((left, right) => left.exportedName.localeCompare(right.exportedName) || left.line - right.line);
+  result.wildcardSources = [...new Set(result.wildcardSources)].sort();
+  result.syntheticDeclarations.sort((left, right) => left.name.localeCompare(right.name));
+  result.diagnostics.sort((left, right) => left.line - right.line || left.column - right.column);
+  return result;
 };
-var traceExports = async (entryPath, fs, resolver = { mappings: [] }) => {
-  const state = {
-    files: new Set,
-    cache: new Map,
-    inFlight: new Set,
-    resolver
-  };
-  const exportsList = await traceFile(entryPath, fs, state);
-  return {
-    exports: uniqueExports(exportsList),
-    files: [...state.files].sort()
-  };
+
+// src/commonJsExportTrace.ts
+var traceCommonJsExports = async (input) => {
+  const traced = [];
+  for (const item of input.analysis.exports) {
+    if (item.localName && input.localDeclarations.has(item.localName)) {
+      traced.push({
+        exportedName: item.exportedName,
+        localName: item.localName,
+        declarationFile: input.filePath
+      });
+      continue;
+    }
+    if (item.source && item.importedName) {
+      traced.push(...await input.traceImported(item.source, item.importedName, item.exportedName));
+    }
+  }
+  for (const source of input.analysis.wildcardSources) {
+    traced.push(...await input.traceWildcard(source));
+  }
+  return traced;
 };
 
-// src/symbolExtractorAst.ts
+// src/exportTracer.ts
 var DECLARATION_TYPES2 = new Set([
   "function_declaration",
   "class_declaration",
@@ -14321,296 +14860,247 @@ var DECLARATION_TYPES2 = new Set([
   "enum_declaration",
   "lexical_declaration"
 ]);
-var BUILTIN_TYPES = new Set([
-  "Array",
-  "Boolean",
-  "Date",
-  "Error",
-  "Map",
-  "Number",
-  "Object",
-  "Promise",
-  "ReadonlyArray",
-  "Record",
-  "Set",
-  "String",
-  "unknown",
-  "void",
-  "string",
-  "number",
-  "boolean",
-  "null",
-  "undefined",
-  "never",
-  "any"
-]);
-var countLines = (source) => {
-  if (!source)
-    return 0;
-  return source.split(/\r\n|\r|\n/).filter((line) => line.trim().length > 0).length;
-};
-var createRelation = (type, from, to, isExternal, line) => ({
-  type,
-  from,
-  to,
-  isExternal,
-  grounding: "code" /* Code */,
-  confidence: 1,
-  source: "ast" /* Ast */,
-  ...line ? { line } : {}
-});
-var getLine = (node2) => node2.startPosition.row + 1;
-var getEndLine = (node2) => node2.endPosition.row + 1;
-var extractJSDoc = (node2) => {
-  const prev = node2.previousNamedSibling ?? node2.parent?.previousNamedSibling;
-  if (!prev || prev.type !== "comment")
-    return;
-  const text = prev.text;
-  if (!text.startsWith("/**"))
-    return;
-  const cleaned = text.replace(/^\/\*\*\s*/, "").replace(/\s*\*\/$/, "").replace(/^\s*\* ?/gm, "").trim();
-  return cleaned || undefined;
-};
-var extractTypeAnnotation = (node2) => {
-  if (!node2)
-    return null;
-  return node2.text.replace(/^:\s*/, "").trim() || null;
-};
-var getNameNodeText = (node2) => node2?.text?.trim() ? node2.text.trim() : null;
-var getReturnType = (node2) => {
-  const returnNode = node2.childForFieldName("return_type") ?? node2.namedChildren.find((child) => child.type === "type_annotation") ?? null;
-  return extractTypeAnnotation(returnNode);
-};
-var getInitializer = (node2) => node2.childForFieldName("value") ?? node2.namedChildren.find((child) => child.type === "arrow_function" || child.type === "function" || child.type === "call_expression") ?? null;
-var getCallableFromInitializer = (node2) => {
-  if (!node2)
-    return null;
-  if (node2.type === "arrow_function" || node2.type === "function")
-    return node2;
-  if (node2.type === "call_expression") {
-    return node2.namedChildren.find((child) => child.type === "arrow_function" || child.type === "function") ?? null;
-  }
-  return null;
-};
-var getInitializerTypeAnnotation = (node2) => {
-  if (!node2 || node2.type !== "call_expression")
-    return null;
-  const typeArguments = node2.namedChildren.find((child) => child.type === "type_arguments") ?? null;
-  if (!typeArguments)
-    return null;
-  const callee = node2.namedChildren.find((child) => child.type !== "type_arguments" && child.type !== "arguments") ?? null;
-  const calleeText = callee?.text?.trim();
-  return calleeText ? `${calleeText}${typeArguments.text}` : typeArguments.text;
-};
-var getInitializerText = (node2, options = {}) => {
-  if (!node2)
-    return null;
-  if ((node2.type === "arrow_function" || node2.type === "function") && !options.includeCallable)
-    return null;
-  const text = node2.text.trim();
-  if ((node2.type === "arrow_function" || node2.type === "function") && text.length > 600)
-    return null;
-  return text.length > 0 ? text : null;
-};
-var inferReturnType = (node2) => {
-  if (!node2)
-    return null;
-  return containsJsx(node2) ? "JSX.Element" : null;
-};
-var containsJsx = (node2) => {
-  if (node2.type.startsWith("jsx_"))
-    return true;
-  return node2.namedChildren.some(containsJsx);
-};
-var getTypeNames = (typeText) => {
-  if (!typeText)
-    return [];
-  const matches = typeText.match(/\b[A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*\b/g) ?? [];
-  return [...new Set(matches)].filter((match) => !BUILTIN_TYPES.has(match));
-};
-var resolveTypeBinding = (typeName, importBindings, declarations) => {
-  const localName = typeName.split(".")[0] ?? typeName;
-  const importBinding = importBindings.get(localName);
-  if (importBinding)
-    return importBinding.isExternal;
-  if (declarations.has(localName))
-    return false;
-  return false;
-};
-var appendTypeRelations = (relations, relationType, from, typeText, importBindings, declarations, line) => {
-  for (const typeName of getTypeNames(typeText)) {
-    relations.push(createRelation(relationType, from, typeName, resolveTypeBinding(typeName, importBindings, declarations), line));
-  }
-};
-var classifyVariable = (name, filePath) => {
-  if ((filePath.endsWith(".tsx") || filePath.endsWith(".jsx")) && /^[A-Z]/.test(name)) {
-    return "component" /* Component */;
+var stripQuotes = (value) => value.replace(/^['"]/, "").replace(/['"]$/, "");
+var getDeclarationName = (node2) => {
+  if (node2.type === "lexical_declaration") {
+    return node2.namedChildren.filter((child) => child.type === "variable_declarator").map((child) => child.childForFieldName("name")?.text ?? child.namedChildren[0]?.text ?? "").filter(Boolean);
   }
-  return "variable" /* Variable */;
-};
-var collectParams = (node2) => {
-  if (!node2)
-    return [];
-  return node2.namedChildren.map((child) => {
-    const wrapper = child;
-    const target = child.type === "required_parameter" || child.type === "optional_parameter" ? child.namedChildren[0] ?? child : child;
-    const nameNode = target.childForFieldName("name") ?? target.namedChildren.find((candidate) => candidate.type === "identifier" || candidate.type === "property_identifier") ?? target.namedChildren[0] ?? target;
-    const typeNode = wrapper.childForFieldName("type") ?? wrapper.namedChildren.find((candidate) => candidate.type === "type_annotation") ?? target.childForFieldName("type") ?? target.namedChildren.find((candidate) => candidate.type === "type_annotation") ?? null;
-    return {
-      name: nameNode.text,
-      type: extractTypeAnnotation(typeNode)
-    };
-  });
+  const nameNode = node2.childForFieldName("name") ?? node2.namedChildren.find((child) => child.type === "identifier" || child.type === "type_identifier");
+  return nameNode?.text ? [nameNode.text] : [];
 };
-var collectMembers = (node2, declarations, importBindings, ownerName, relations) => {
-  if (!node2)
-    return;
-  const members = [];
-  for (const child of node2.namedChildren) {
-    if (child.type === "public_field_definition" || child.type === "property_signature") {
-      const nameNode = child.childForFieldName("name") ?? child.namedChildren.find((candidate) => candidate.type === "property_identifier" || candidate.type === "identifier");
-      if (!nameNode)
-        continue;
-      const typeNode = child.childForFieldName("type") ?? child.namedChildren.find((candidate) => candidate.type === "type_annotation") ?? null;
-      const typeAnnotation = extractTypeAnnotation(typeNode);
-      const propDoc = extractJSDoc(child);
-      members.push({
-        name: nameNode.text,
-        kind: "prop" /* Prop */,
-        visibility: "internal" /* Internal */,
-        file: "",
-        line: getLine(child),
-        endLine: getEndLine(child),
-        ...typeAnnotation ? { typeAnnotation } : {},
-        ...propDoc ? { doc: propDoc } : {}
-      });
-      appendTypeRelations(relations, "of_type" /* OfType */, ownerName, typeAnnotation, importBindings, declarations, getLine(child));
-      continue;
-    }
-    const indexMember = indexSignatureMember(child);
-    if (indexMember) {
-      members.push(indexMember.info);
-      appendTypeRelations(relations, "of_type" /* OfType */, ownerName, indexMember.typeAnnotation, importBindings, declarations, getLine(child));
-      continue;
-    }
-    if (child.type === "method_definition" || child.type === "method_signature") {
-      const nameNode = child.childForFieldName("name") ?? child.namedChildren.find((candidate) => candidate.type === "property_identifier" || candidate.type === "identifier");
-      if (!nameNode)
-        continue;
-      const paramsNode = child.childForFieldName("parameters") ?? child.namedChildren.find((candidate) => candidate.type === "formal_parameters") ?? null;
-      const params = collectParams(paramsNode);
-      const returnType = getReturnType(child);
-      const methodDoc = extractJSDoc(child);
-      members.push({
-        name: nameNode.text,
-        kind: "method" /* Method */,
-        visibility: "internal" /* Internal */,
-        file: "",
-        line: getLine(child),
-        endLine: getEndLine(child),
-        ...params.length > 0 ? { params } : {},
-        ...returnType ? { returnType } : {},
-        ...methodDoc ? { doc: methodDoc } : {}
-      });
-      for (const param of params) {
-        appendTypeRelations(relations, "param_type" /* ParamType */, ownerName, param.type, importBindings, declarations, getLine(child));
+var collectLocalDeclarations = (root) => {
+  const declarations = new Map;
+  const register = (node2) => {
+    for (const name of getDeclarationName(node2)) {
+      if (!declarations.has(name)) {
+        declarations.set(name, name);
       }
-      appendTypeRelations(relations, "return_type" /* ReturnType */, ownerName, returnType, importBindings, declarations, getLine(child));
+    }
+  };
+  for (const child of root.namedChildren) {
+    if (DECLARATION_TYPES2.has(child.type)) {
+      register(child);
+      continue;
+    }
+    if (child.type !== "export_statement")
+      continue;
+    const declaration = child.namedChildren.find((node2) => DECLARATION_TYPES2.has(node2.type));
+    if (declaration) {
+      register(declaration);
     }
   }
-  return members.length > 0 ? members : undefined;
+  return declarations;
 };
-var indexSignatureMember = (node2) => {
-  if (node2.type !== "index_signature")
+var parseExportSpecifier = (node2) => {
+  const identifiers = node2.namedChildren.filter((child) => child.type === "identifier" || child.type === "type_identifier").map((child) => child.text);
+  if (identifiers.length === 0)
     return null;
-  const match = /^\s*(\[[^\]]+\])\s*:?\s*([^;]+)?;?\s*$/u.exec(node2.text);
-  const name = match?.[1]?.trim();
-  const typeAnnotation = match?.[2]?.trim();
-  if (!name)
+  const localName = identifiers[0];
+  const exportedName = identifiers[1] ?? localName;
+  return { localName, exportedName };
+};
+var parseImportSpecifier = (node2) => {
+  const identifiers = node2.namedChildren.filter((child) => child.type === "identifier" || child.type === "type_identifier").map((child) => child.text);
+  if (identifiers.length === 0)
     return null;
-  const propDoc = extractJSDoc(node2);
-  return {
-    info: {
-      name,
-      kind: "prop" /* Prop */,
-      visibility: "internal" /* Internal */,
-      file: "",
-      line: getLine(node2),
-      endLine: getEndLine(node2),
-      ...typeAnnotation ? { typeAnnotation } : {},
-      ...propDoc ? { doc: propDoc } : {}
-    },
-    typeAnnotation
-  };
+  const importedName = identifiers[0];
+  const localName = identifiers[1] ?? importedName;
+  return { importedName, localName };
 };
-var collectEnumValues = (node2) => {
-  const body = node2.namedChildren.find((child) => child.type === "enum_body") ?? null;
-  if (!body)
-    return;
-  const values = [];
-  for (const member of body.namedChildren.filter((child) => child.type === "enum_assignment" || child.type === "property_identifier")) {
-    if (member.type === "property_identifier") {
-      values.push(member.text);
+var collectImportBindings = (root) => {
+  const bindings = new Map;
+  for (const node2 of root.namedChildren) {
+    if (node2.type !== "import_statement")
       continue;
-    }
-    const name = member.childForFieldName("name")?.text ?? member.namedChildren[0]?.text;
-    if (!name)
+    const stringNode = node2.namedChildren.find((child) => child.type === "string");
+    if (!stringNode)
       continue;
-    const valueNode = member.childForFieldName("value") ?? member.namedChildren.find((child) => child !== member.childForFieldName("name")) ?? null;
-    const rawValue = valueNode?.text.replace(/^['"]|['"]$/gu, "");
-    values.push(rawValue ? `${name} = ${rawValue}` : name);
-  }
-  return values.length > 0 ? values : undefined;
-};
-var extractUnionLiteralValues = (typeNode) => {
-  if (!typeNode)
-    return;
-  if (typeNode.type === "literal_type") {
-    const text = typeNode.text.replace(/^['"]|['"]$/g, "");
-    return text ? [text] : undefined;
-  }
-  if (typeNode.type === "union_type") {
-    const values = [];
-    for (const child of typeNode.namedChildren) {
-      if (child.type === "literal_type") {
-        const text = child.text.replace(/^['"]|['"]$/g, "");
-        if (text)
-          values.push(text);
-      } else if (child.type === "union_type") {
-        const nested = extractUnionLiteralValues(child);
-        if (!nested)
-          return;
-        values.push(...nested);
-      } else {
-        return;
+    const source = stripQuotes(stringNode.text);
+    const clause = node2.namedChildren.find((child) => child.type === "import_clause");
+    for (const part of clause?.namedChildren ?? []) {
+      if (part.type === "identifier") {
+        bindings.set(part.text, { source, importedName: "default" });
+        continue;
+      }
+      if (part.type !== "named_imports")
+        continue;
+      for (const specifier of part.namedChildren.filter((child) => child.type === "import_specifier")) {
+        const parsed = parseImportSpecifier(specifier);
+        if (parsed) {
+          bindings.set(parsed.localName, { source, importedName: parsed.importedName });
+        }
       }
     }
-    return values.length > 0 ? values : undefined;
   }
-  return;
+  return bindings;
 };
-var findObjectTypeNodes = (node2) => {
-  if (!node2)
+var uniqueExports = (exportsList) => {
+  const seen = new Set;
+  return exportsList.filter((item) => {
+    const key = `${item.declarationFile}::${item.localName}::${item.exportedName}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+};
+var traceImportedBinding = async (filePath, binding, exportedName, fs, state) => {
+  const targetPath = await resolveImportSourcePath(filePath, binding.source, fs, state.resolver);
+  if (!targetPath)
     return [];
-  if (node2.type === "object_type")
-    return [node2];
-  if (node2.type === "intersection_type" || node2.type === "union_type") {
-    return node2.namedChildren.flatMap(findObjectTypeNodes);
-  }
-  if (node2.type === "parenthesized_type" && node2.namedChildCount > 0) {
-    return findObjectTypeNodes(node2.namedChildren[0]);
-  }
-  return [];
+  const traced = await traceFile(targetPath, fs, state);
+  const match = traced.find((item) => item.exportedName === binding.importedName || binding.importedName === "default" && item.exportedName === item.localName);
+  if (!match)
+    return [];
+  return [{
+    exportedName,
+    localName: match.localName,
+    declarationFile: match.declarationFile
+  }];
+};
+var traceFile = async (filePath, fs, state) => {
+  const cached = state.cache.get(filePath);
+  if (cached)
+    return cached;
+  if (state.inFlight.has(filePath))
+    return [];
+  const promise = (async () => {
+    state.inFlight.add(filePath);
+    state.files.add(filePath);
+    const source = await fs.readFile(filePath);
+    const commonJs = analyzeCommonJsModule(source, filePath);
+    if (commonJs.diagnostics.length > 0)
+      return [];
+    const jsxLike = isJsxLikePath(filePath);
+    const parserSource = jsxLike ? treeSitterCompatibleJsxSource(createEcmaScriptSourceFile(source, filePath), source) : source;
+    const tree = await parseFile(parserSource, jsxLike);
+    if (!tree)
+      return [];
+    try {
+      const root = tree.rootNode;
+      const localDeclarations = collectLocalDeclarations(root);
+      const importBindings = collectImportBindings(root);
+      for (const declaration of commonJs.syntheticDeclarations) {
+        localDeclarations.set(declaration.name, declaration.name);
+      }
+      for (const binding of commonJs.bindings) {
+        importBindings.set(binding.localName, {
+          source: binding.source,
+          importedName: binding.importedName
+        });
+      }
+      const exportsList = [];
+      for (const node2 of root.namedChildren) {
+        if (node2.type !== "export_statement")
+          continue;
+        const stringNode = node2.namedChildren.find((child) => child.type === "string");
+        const exportClause = node2.namedChildren.find((child) => child.type === "export_clause");
+        const declaration = node2.namedChildren.find((child) => DECLARATION_TYPES2.has(child.type));
+        if (declaration) {
+          for (const name of getDeclarationName(declaration)) {
+            exportsList.push({ exportedName: name, localName: name, declarationFile: filePath });
+          }
+          continue;
+        }
+        if (node2.text.startsWith("export default ")) {
+          const identifier = node2.namedChildren.find((child) => child.type === "identifier" || child.type === "type_identifier");
+          if (identifier && localDeclarations.has(identifier.text)) {
+            exportsList.push({
+              exportedName: identifier.text,
+              localName: identifier.text,
+              declarationFile: filePath
+            });
+          }
+          continue;
+        }
+        if (!exportClause) {
+          if (stringNode && node2.text.startsWith("export *")) {
+            const targetPath2 = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs, state.resolver);
+            if (targetPath2) {
+              exportsList.push(...await traceFile(targetPath2, fs, state));
+            }
+          }
+          continue;
+        }
+        if (!stringNode) {
+          for (const specifier of exportClause.namedChildren.filter((child) => child.type === "export_specifier")) {
+            const parsed = parseExportSpecifier(specifier);
+            if (!parsed)
+              continue;
+            if (localDeclarations.has(parsed.localName)) {
+              exportsList.push({
+                exportedName: parsed.exportedName,
+                localName: parsed.localName,
+                declarationFile: filePath
+              });
+              continue;
+            }
+            const importBinding = importBindings.get(parsed.localName);
+            if (importBinding) {
+              exportsList.push(...await traceImportedBinding(filePath, importBinding, parsed.exportedName, fs, state));
+            }
+          }
+          continue;
+        }
+        const targetPath = await resolveImportSourcePath(filePath, stripQuotes(stringNode.text), fs, state.resolver);
+        if (!targetPath)
+          continue;
+        const traced = await traceFile(targetPath, fs, state);
+        for (const specifier of exportClause.namedChildren.filter((child) => child.type === "export_specifier")) {
+          const parsed = parseExportSpecifier(specifier);
+          if (!parsed)
+            continue;
+          const match = traced.find((item) => item.exportedName === parsed.localName);
+          if (!match)
+            continue;
+          exportsList.push({
+            exportedName: parsed.exportedName,
+            localName: match.localName,
+            declarationFile: match.declarationFile
+          });
+        }
+      }
+      exportsList.push(...await traceCommonJsExports({
+        analysis: commonJs,
+        filePath,
+        localDeclarations,
+        traceImported: (source2, importedName, exportedName) => traceImportedBinding(filePath, { source: source2, importedName }, exportedName, fs, state),
+        traceWildcard: async (source2) => {
+          const targetPath = await resolveImportSourcePath(filePath, source2, fs, state.resolver);
+          return targetPath ? traceFile(targetPath, fs, state) : [];
+        }
+      }));
+      return uniqueExports(exportsList);
+    } finally {
+      tree.delete();
+      state.inFlight.delete(filePath);
+    }
+  })();
+  state.cache.set(filePath, promise);
+  return promise;
+};
+var traceExports = async (entryPath, fs, resolver = { mappings: [] }) => {
+  const state = {
+    files: new Set,
+    cache: new Map,
+    inFlight: new Set,
+    resolver
+  };
+  const exportsList = await traceFile(entryPath, fs, state);
+  return {
+    exports: uniqueExports(exportsList),
+    files: [...state.files].sort()
+  };
 };
 
 // src/staticCallRelations.ts
-import ts3 from "typescript";
+import ts8 from "typescript";
 var callTarget = (expression, sourceFile) => {
-  if (ts3.isIdentifier(expression))
+  if (ts8.isIdentifier(expression))
     return expression.text === "require" ? null : expression.text;
-  if (ts3.isPropertyAccessExpression(expression))
+  if (ts8.isPropertyAccessExpression(expression))
     return expression.getText(sourceFile).replace(/\s+/gu, "");
-  if (ts3.isElementAccessExpression(expression)) {
+  if (ts8.isElementAccessExpression(expression)) {
     const property = staticStringValue(expression.argumentExpression);
     return property ? `${expression.expression.getText(sourceFile).replace(/\s+/gu, "")}.${property}` : null;
   }
@@ -14618,32 +15108,31 @@ var callTarget = (expression, sourceFile) => {
 };
 var rootIdentifier = (expression) => {
   let current = expression;
-  while (ts3.isPropertyAccessExpression(current) || ts3.isElementAccessExpression(current)) {
+  while (ts8.isPropertyAccessExpression(current) || ts8.isElementAccessExpression(current)) {
     current = current.expression;
   }
-  return ts3.isIdentifier(current) ? current.text : null;
+  return ts8.isIdentifier(current) ? current.text : null;
 };
 var declarationName = (node2, sourceFile) => {
-  if (ts3.isFunctionDeclaration(node2) && node2.name)
+  if (ts8.isFunctionDeclaration(node2) && node2.name)
     return node2.name.text;
-  if (ts3.isClassDeclaration(node2) && node2.name)
+  if (ts8.isClassDeclaration(node2) && node2.name)
     return node2.name.text;
-  if (ts3.isVariableDeclaration(node2) && ts3.isIdentifier(node2.name))
+  if (ts8.isVariableDeclaration(node2) && ts8.isIdentifier(node2.name))
     return node2.name.text;
-  if (ts3.isMethodDeclaration(node2) || ts3.isGetAccessorDeclaration(node2) || ts3.isSetAccessorDeclaration(node2)) {
+  if (ts8.isMethodDeclaration(node2) || ts8.isGetAccessorDeclaration(node2) || ts8.isSetAccessorDeclaration(node2)) {
     const parent = node2.parent;
-    if (parent && ts3.isClassDeclaration(parent) && parent.name)
+    if (parent && ts8.isClassDeclaration(parent) && parent.name)
       return parent.name.text;
     return node2.name?.getText(sourceFile) ?? null;
   }
   return null;
 };
-var collectStaticCallRelations = (source, filePath, importBindings) => {
-  const sourceFile = createEcmaScriptSourceFile(source, filePath);
+var collectStaticCallRelations = (source, filePath, importBindings, sourceFile = createEcmaScriptSourceFile(source, filePath)) => {
   const relations = [];
   const visit2 = (node2, owner) => {
     const namedOwner = declarationName(node2, sourceFile) ?? owner;
-    if (ts3.isCallExpression(node2) || ts3.isNewExpression(node2)) {
+    if (ts8.isCallExpression(node2) || ts8.isNewExpression(node2)) {
       const target = callTarget(node2.expression, sourceFile);
       if (target) {
         const root = rootIdentifier(node2.expression);
@@ -14651,7 +15140,7 @@ var collectStaticCallRelations = (source, filePath, importBindings) => {
         relations.push(createRelation("calls" /* Calls */, namedOwner, target, isExternal, nodeLocation(sourceFile, node2).line));
       }
     }
-    ts3.forEachChild(node2, (child) => visit2(child, namedOwner));
+    ts8.forEachChild(node2, (child) => visit2(child, namedOwner));
   };
   visit2(sourceFile, filePath);
   const seen = new Set;
@@ -14786,10 +15275,10 @@ var analyzeLexicalDeclaration = (node2, filePath, declarations, importBindings,
       continue;
     const typeNode = declarator.childForFieldName("type") ?? declarator.namedChildren.find((child) => child.type === "type_annotation") ?? null;
     const initializer = getInitializer(declarator);
-    const callable = getCallableFromInitializer(initializer);
-    const paramsNode = callable?.childForFieldName("parameters") ?? callable?.namedChildren.find((child) => child.type === "formal_parameters") ?? null;
+    const callable2 = getCallableFromInitializer(initializer);
+    const paramsNode = callable2?.childForFieldName("parameters") ?? callable2?.namedChildren.find((child) => child.type === "formal_parameters") ?? null;
     const params = collectParams(paramsNode);
-    const returnType = callable ? getReturnType(callable) ?? inferReturnType(callable) : null;
+    const returnType = callable2 ? getReturnType(callable2) ?? inferReturnType(callable2) : null;
     const initializerTypeAnnotation = getInitializerTypeAnnotation(initializer);
     const typeAnnotation = extractTypeAnnotation(typeNode) ?? initializerTypeAnnotation;
     const initializerText = getInitializerText(initializer, {
@@ -14815,7 +15304,7 @@ var analyzeLexicalDeclaration = (node2, filePath, declarations, importBindings,
       appendTypeRelations(relations, "param_type" /* ParamType */, nameNode.text, param.type, importBindings, declarations, getLine(declarator));
     }
     appendTypeRelations(relations, "return_type" /* ReturnType */, nameNode.text, returnType, importBindings, declarations, getLine(declarator));
-    appendTypeRelations(relations, "of_type" /* OfType */, nameNode.text, typeAnnotation, importBindings, declarations, getLine(declarator));
+    appendTypeRelations(relations, "of_type" /* OfType */, nameNode.text, extractTypeAnnotation(typeNode) ?? getInitializerTypeAnnotation(initializer, { referencesOnly: true }), importBindings, declarations, getLine(declarator));
   }
 };
 var analyzeFunctionDeclaration = (node2, name, filePath, declarations, importBindings, relations) => {
@@ -14823,7 +15312,8 @@ var analyzeFunctionDeclaration = (node2, name, filePath, declarations, importBin
   const params = collectParams(paramsNode);
   const returnType = getReturnType(node2);
   const funcDoc = extractJSDoc(node2);
-  const signature = `${name}(${params.map((param) => `${param.name}${param.type ? `: ${param.type}` : ""}`).join(", ")})`;
+  const body = node2.childForFieldName("body");
+  const signature = body === null ? node2.text : node2.text.slice(0, body.startIndex - node2.startIndex).trimEnd();
   declarations.set(name, {
     info: {
       name,
@@ -14954,7 +15444,7 @@ var appendCommonJsSyntheticDeclarations = (commonJs, filePath, declarations) =>
 var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
   const source = await fs.readFile(filePath);
   const sourceFile = createEcmaScriptSourceFile(source, filePath);
-  const commonJs = analyzeCommonJsModule(source, filePath);
+  const commonJs = analyzeCommonJsModule(source, filePath, sourceFile);
   const jsxLike = isJsxLikePath(filePath);
   const parserSource = jsxLike ? treeSitterCompatibleJsxSource(sourceFile, source) : source;
   const tree = await parseFile(parserSource, jsxLike);
@@ -14978,47 +15468,51 @@ var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
       diagnostics
     };
   }
-  if (commonJs.diagnostics.length > 0) {
-    return {
-      declarations: new Map,
-      importBindings: new Map,
-      relations: [],
-      lines: countLines(source),
-      disposition: "unsupported",
-      diagnostics: commonJs.diagnostics
-    };
-  }
-  const root = tree.rootNode;
-  const relations = [];
-  const importBindings = await collectImportBindings2(root, filePath, fs, resolver, relations, commonJs);
-  const declarations = new Map;
-  for (const relation of relations) {
-    if (relation.from === "") {
-      relation.from = filePath;
+  try {
+    if (commonJs.diagnostics.length > 0) {
+      return {
+        declarations: new Map,
+        importBindings: new Map,
+        relations: [],
+        lines: countLines(source),
+        disposition: "unsupported",
+        diagnostics: commonJs.diagnostics
+      };
     }
-  }
-  for (const child of root.namedChildren) {
-    if (DECLARATION_TYPES2.has(child.type)) {
-      analyzeDeclaration(child, filePath, declarations, importBindings, relations);
-      continue;
+    const root = tree.rootNode;
+    const relations = [];
+    const importBindings = await collectImportBindings2(root, filePath, fs, resolver, relations, commonJs);
+    const declarations = new Map;
+    for (const relation of relations) {
+      if (relation.from === "") {
+        relation.from = filePath;
+      }
     }
-    if (child.type !== "export_statement")
-      continue;
-    const declaration = child.namedChildren.find((node2) => DECLARATION_TYPES2.has(node2.type));
-    if (declaration) {
-      analyzeDeclaration(declaration, filePath, declarations, importBindings, relations);
+    for (const child of root.namedChildren) {
+      if (DECLARATION_TYPES.has(child.type)) {
+        analyzeDeclaration(child, filePath, declarations, importBindings, relations);
+        continue;
+      }
+      if (child.type !== "export_statement")
+        continue;
+      const declaration = child.namedChildren.find((node2) => DECLARATION_TYPES.has(node2.type));
+      if (declaration) {
+        analyzeDeclaration(declaration, filePath, declarations, importBindings, relations);
+      }
     }
+    appendCommonJsSyntheticDeclarations(commonJs, filePath, declarations);
+    relations.push(...collectStaticCallRelations(source, filePath, importBindings, sourceFile));
+    return {
+      declarations,
+      importBindings,
+      relations: relations.map((relation) => ({ ...relation, file: filePath })),
+      lines: countLines(source),
+      disposition: "analyzed",
+      diagnostics: []
+    };
+  } finally {
+    tree.delete();
   }
-  appendCommonJsSyntheticDeclarations(commonJs, filePath, declarations);
-  relations.push(...collectStaticCallRelations(source, filePath, importBindings));
-  return {
-    declarations,
-    importBindings,
-    relations,
-    lines: countLines(source),
-    disposition: "analyzed",
-    diagnostics: []
-  };
 };
 
 // src/symbolExtractor.ts
@@ -15030,6 +15524,7 @@ var relationIdentity = (relation) => JSON.stringify([
   relation.grounding,
   relation.confidence,
   relation.source,
+  relation.file ?? null,
   relation.line ?? null
 ]);
 var uniqueRelations = (relations) => {
@@ -15069,14 +15564,19 @@ var extractSymbols = async (entries, fs, options) => {
         continue;
       const declKey = `${tracedExport.declarationFile}::${tracedExport.localName}`;
       const exportKey = `${declKey}::${tracedExport.exportedName}`;
-      if (exportedDeclarationKeys.has(exportKey))
+      if (exportedDeclarationKeys.has(exportKey)) {
+        const existing = exportedSymbols.find((symbol) => symbol.file === tracedExport.declarationFile && symbol.name === tracedExport.exportedName);
+        if (existing !== undefined)
+          existing.publicEntrypoints = [...new Set([...existing.publicEntrypoints, entry.path])].sort();
         continue;
+      }
       exportedDeclarationKeys.add(declKey);
       exportedDeclarationKeys.add(exportKey);
       exportedSymbols.push({
         ...declaration.info,
         name: tracedExport.exportedName,
-        visibility: "exported" /* Exported */
+        visibility: "exported" /* Exported */,
+        publicEntrypoints: [entry.path]
       });
     }
   }
@@ -15098,34 +15598,7 @@ var extractSymbols = async (entries, fs, options) => {
     }
   }
   const symbols = [...exportedSymbols, ...internalSymbols];
-  const typeDeclarations = new Map;
-  for (const analysis of analyses.values()) {
-    for (const [name, decl] of analysis.declarations) {
-      if (decl.info.kind === "interface" || decl.info.kind === "type") {
-        typeDeclarations.set(name, decl.info.file);
-      }
-    }
-  }
-  for (const sym of symbols) {
-    if (sym.kind !== "component")
-      continue;
-    let propsTypeName;
-    if (sym.typeAnnotation) {
-      const genericBody = /<(.+)>/u.exec(sym.typeAnnotation)?.[1];
-      const genericNames = genericBody?.match(/\b[A-Z][A-Za-z0-9_]*\b/gu) ?? [];
-      propsTypeName = genericNames.filter((name) => typeDeclarations.has(name)).at(-1);
-    }
-    if (!propsTypeName) {
-      const conventionName = `${sym.name}Props`;
-      if (typeDeclarations.has(conventionName)) {
-        propsTypeName = conventionName;
-      }
-    }
-    if (propsTypeName) {
-      sym.propsType = propsTypeName;
-      relations.push(createRelation("of_type" /* OfType */, sym.name, propsTypeName, false, sym.line));
-    }
-  }
+  await enrichPublicContracts({ symbols, paths: [...analyses.keys()], fs, resolver, relations });
   const deduplicatedRelations = uniqueRelations(relations);
   const files = [...filePaths].sort().map((filePath) => ({
     path: filePath,
@@ -15224,20 +15697,20 @@ class TypeScriptPlugin {
   }
 }
 // src/reactRouter.ts
-import * as ts4 from "typescript";
+import * as ts9 from "typescript";
 function compact(value) {
   return value.replace(/\s+/gu, " ").trim();
 }
 function scalarValue(node2) {
   if (!node2)
     return;
-  if (ts4.isStringLiteralLike(node2) || ts4.isNoSubstitutionTemplateLiteral(node2))
+  if (ts9.isStringLiteralLike(node2) || ts9.isNoSubstitutionTemplateLiteral(node2))
     return node2.text;
-  if (ts4.isNumericLiteral(node2))
+  if (ts9.isNumericLiteral(node2))
     return Number(node2.text);
-  if (node2.kind === ts4.SyntaxKind.TrueKeyword)
+  if (node2.kind === ts9.SyntaxKind.TrueKeyword)
     return true;
-  if (node2.kind === ts4.SyntaxKind.FalseKeyword)
+  if (node2.kind === ts9.SyntaxKind.FalseKeyword)
     return false;
   return;
 }
@@ -15246,37 +15719,37 @@ function findDynamicImport(node2) {
   const visit2 = (child) => {
     if (result)
       return;
-    if (ts4.isCallExpression(child) && child.expression.kind === ts4.SyntaxKind.ImportKeyword && child.arguments[0] && ts4.isStringLiteralLike(child.arguments[0])) {
+    if (ts9.isCallExpression(child) && child.expression.kind === ts9.SyntaxKind.ImportKeyword && child.arguments[0] && ts9.isStringLiteralLike(child.arguments[0])) {
       result = child.arguments[0].text;
       return;
     }
-    ts4.forEachChild(child, visit2);
+    ts9.forEachChild(child, visit2);
   };
   visit2(node2);
   return result;
 }
 function parseSource(source, filePath) {
-  const sourceFile = ts4.createSourceFile(filePath, source, ts4.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts4.ScriptKind.TSX : ts4.ScriptKind.TS);
+  const sourceFile = ts9.createSourceFile(filePath, source, ts9.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts9.ScriptKind.TSX : ts9.ScriptKind.TS);
   const imports = new Map;
   const constants2 = new Map;
   for (const statement of sourceFile.statements) {
-    if (ts4.isImportDeclaration(statement) && ts4.isStringLiteral(statement.moduleSpecifier)) {
+    if (ts9.isImportDeclaration(statement) && ts9.isStringLiteral(statement.moduleSpecifier)) {
       const moduleSource = statement.moduleSpecifier.text;
       const clause = statement.importClause;
       if (clause?.name)
         imports.set(clause.name.text, moduleSource);
       const bindings = clause?.namedBindings;
-      if (bindings && ts4.isNamedImports(bindings)) {
+      if (bindings && ts9.isNamedImports(bindings)) {
         for (const element of bindings.elements)
           imports.set(element.name.text, moduleSource);
       }
-      if (bindings && ts4.isNamespaceImport(bindings))
+      if (bindings && ts9.isNamespaceImport(bindings))
         imports.set(bindings.name.text, moduleSource);
     }
-    if (!ts4.isVariableStatement(statement))
+    if (!ts9.isVariableStatement(statement))
       continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts4.isIdentifier(declaration.name) || !declaration.initializer)
+      if (!ts9.isIdentifier(declaration.name) || !declaration.initializer)
         continue;
       const scalar = scalarValue(declaration.initializer);
       if (scalar !== undefined)
@@ -15305,13 +15778,13 @@ function routeConditions(node2, sourceFile) {
   let current = node2;
   while (current?.parent) {
     const parent = current.parent;
-    if (ts4.isConditionalExpression(parent)) {
+    if (ts9.isConditionalExpression(parent)) {
       const condition = compact(parent.condition.getText(sourceFile));
       conditions.push(current === parent.whenTrue ? condition : `!(${condition})`);
-    } else if (ts4.isBinaryExpression(parent) && parent.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandToken && current === parent.right) {
+    } else if (ts9.isBinaryExpression(parent) && parent.operatorToken.kind === ts9.SyntaxKind.AmpersandAmpersandToken && current === parent.right) {
       conditions.push(compact(parent.left.getText(sourceFile)));
     }
-    if (ts4.isFunctionLike(parent))
+    if (ts9.isFunctionLike(parent))
       break;
     current = parent;
   }
@@ -15320,36 +15793,36 @@ function routeConditions(node2, sourceFile) {
 function jsxAttributes(node2) {
   const result = new Map;
   for (const property of node2.attributes.properties)
-    if (ts4.isJsxAttribute(property))
+    if (ts9.isJsxAttribute(property))
       result.set(property.name.getText(), property);
   return result;
 }
 function jsxExpression(attribute) {
   const initializer = attribute?.initializer;
-  return initializer && ts4.isJsxExpression(initializer) ? initializer.expression : undefined;
+  return initializer && ts9.isJsxExpression(initializer) ? initializer.expression : undefined;
 }
 function jsxScalar(attribute, constants2) {
   if (!attribute)
     return;
   if (!attribute.initializer)
     return true;
-  if (ts4.isStringLiteral(attribute.initializer))
+  if (ts9.isStringLiteral(attribute.initializer))
     return attribute.initializer.text;
   const expression = jsxExpression(attribute);
-  return scalarValue(expression) ?? (expression && ts4.isIdentifier(expression) ? constants2.get(expression.text) : undefined);
+  return scalarValue(expression) ?? (expression && ts9.isIdentifier(expression) ? constants2.get(expression.text) : undefined);
 }
 function descendantTags(node2) {
   const tags = new Set;
   const visit2 = (child) => {
-    if (ts4.isJsxElement(child) || ts4.isJsxSelfClosingElement(child)) {
-      const opening = ts4.isJsxElement(child) ? child.openingElement : child;
+    if (ts9.isJsxElement(child) || ts9.isJsxSelfClosingElement(child)) {
+      const opening = ts9.isJsxElement(child) ? child.openingElement : child;
       const tag = opening.tagName.getText();
       if (child !== node2 && tag === "Route")
         return;
       if (!["Route", "Routes", "Suspense", "Fragment", "React.Fragment", "Navigate"].includes(tag))
         tags.add(tag);
     }
-    ts4.forEachChild(child, visit2);
+    ts9.forEachChild(child, visit2);
   };
   visit2(node2);
   return [...tags];
@@ -15359,8 +15832,8 @@ function navigateTarget(node2, sourceFile) {
   const visit2 = (child) => {
     if (target)
       return;
-    if (ts4.isJsxElement(child) || ts4.isJsxSelfClosingElement(child)) {
-      const opening = ts4.isJsxElement(child) ? child.openingElement : child;
+    if (ts9.isJsxElement(child) || ts9.isJsxSelfClosingElement(child)) {
+      const opening = ts9.isJsxElement(child) ? child.openingElement : child;
       if (child !== node2 && opening.tagName.getText() === "Route")
         return;
       if (opening.tagName.getText() === "Navigate") {
@@ -15375,7 +15848,7 @@ function navigateTarget(node2, sourceFile) {
         }
       }
     }
-    ts4.forEachChild(child, visit2);
+    ts9.forEachChild(child, visit2);
   };
   visit2(node2);
   return target;
@@ -15392,12 +15865,12 @@ function componentSource(component, imports) {
 }
 function objectProperty(object2, name) {
   for (const property of object2.properties) {
-    if (!ts4.isPropertyAssignment(property) && !ts4.isShorthandPropertyAssignment(property))
+    if (!ts9.isPropertyAssignment(property) && !ts9.isShorthandPropertyAssignment(property))
       continue;
-    const key = property.name && (ts4.isIdentifier(property.name) || ts4.isStringLiteralLike(property.name)) ? property.name.text : undefined;
+    const key = property.name && (ts9.isIdentifier(property.name) || ts9.isStringLiteralLike(property.name)) ? property.name.text : undefined;
     if (key !== name)
       continue;
-    return ts4.isPropertyAssignment(property) ? property.initializer : property.name;
+    return ts9.isPropertyAssignment(property) ? property.initializer : property.name;
   }
   return;
 }
@@ -15439,7 +15912,7 @@ function extractReactRouterRoutes(source, filePath, options = {}) {
   };
   const visitRouteObjects = (array, parentPath) => {
     for (const element of array.elements) {
-      if (!ts4.isObjectLiteralExpression(element))
+      if (!ts9.isObjectLiteralExpression(element))
         continue;
       const index = scalarValue(objectProperty(element, "index")) === true;
       const pathValue = scalarValue(objectProperty(element, "path"));
@@ -15455,13 +15928,13 @@ function extractReactRouterRoutes(source, filePath, options = {}) {
         index,
         ...component ? { component } : {},
         ...typeof redirect === "string" ? { redirectTo: redirect } : {},
-        ...children && ts4.isArrayLiteralExpression(children) ? { children } : {}
+        ...children && ts9.isArrayLiteralExpression(children) ? { children } : {}
       });
     }
   };
   const visit2 = (node2, parentPath) => {
-    if (ts4.isJsxElement(node2) || ts4.isJsxSelfClosingElement(node2)) {
-      const opening = ts4.isJsxElement(node2) ? node2.openingElement : node2;
+    if (ts9.isJsxElement(node2) || ts9.isJsxSelfClosingElement(node2)) {
+      const opening = ts9.isJsxElement(node2) ? node2.openingElement : node2;
       if (opening.tagName.getText() === "Route") {
         const attributes = jsxAttributes(opening);
         const index = jsxScalar(attributes.get("index"), parsed.constants) === true;
@@ -15474,30 +15947,30 @@ function extractReactRouterRoutes(source, filePath, options = {}) {
         const fullPath = joinRoutePath(parentPath, typeof pathValue === "string" ? pathValue : "", index);
         const redirectTo = navigateTarget(candidateNode, parsed.sourceFile);
         pushRoute({ node: node2, parentPath, path: typeof pathValue === "string" ? pathValue : "", index, ...component ? { component } : {}, candidates, ...redirectTo ? { redirectTo } : {} });
-        if (ts4.isJsxElement(node2))
+        if (ts9.isJsxElement(node2))
           for (const child of node2.children)
             visit2(child, fullPath);
         return;
       }
     }
-    if (ts4.isCallExpression(node2)) {
+    if (ts9.isCallExpression(node2)) {
       const callee = node2.expression.getText(parsed.sourceFile);
-      if ((callee === "createBrowserRouter" || callee === "createHashRouter" || callee === "useRoutes") && node2.arguments[0] && ts4.isArrayLiteralExpression(node2.arguments[0])) {
+      if ((callee === "createBrowserRouter" || callee === "createHashRouter" || callee === "useRoutes") && node2.arguments[0] && ts9.isArrayLiteralExpression(node2.arguments[0])) {
         visitRouteObjects(node2.arguments[0], mountPath);
       }
     }
-    ts4.forEachChild(node2, (child) => visit2(child, parentPath));
+    ts9.forEachChild(node2, (child) => visit2(child, parentPath));
   };
   visit2(parsed.sourceFile, mountPath);
   return routes.sort((left, right) => left.fullPath.localeCompare(right.fullPath) || left.location.startLine - right.location.startLine || left.location.startColumn - right.location.startColumn);
 }
 // src/moduleExports.ts
-import * as ts5 from "typescript";
+import * as ts10 from "typescript";
 function exportedDeclarationName(statement) {
-  const exported = ts5.canHaveModifiers(statement) && ts5.getModifiers(statement)?.some((modifier) => modifier.kind === ts5.SyntaxKind.ExportKeyword);
+  const exported = ts10.canHaveModifiers(statement) && ts10.getModifiers(statement)?.some((modifier) => modifier.kind === ts10.SyntaxKind.ExportKeyword);
   if (!exported)
     return;
-  if ((ts5.isFunctionDeclaration(statement) || ts5.isClassDeclaration(statement) || ts5.isInterfaceDeclaration(statement) || ts5.isTypeAliasDeclaration(statement) || ts5.isEnumDeclaration(statement)) && statement.name) {
+  if ((ts10.isFunctionDeclaration(statement) || ts10.isClassDeclaration(statement) || ts10.isInterfaceDeclaration(statement) || ts10.isTypeAliasDeclaration(statement) || ts10.isEnumDeclaration(statement)) && statement.name) {
     return statement.name.text;
   }
   return;
@@ -15508,17 +15981,17 @@ function extractTypeScriptModuleExports(source, filePath = "module.ts") {
   const wildcard = new Set;
   const targets = new Set;
   for (const statement of sourceFile.statements) {
-    if (ts5.isExportDeclaration(statement)) {
-      const target = statement.moduleSpecifier && ts5.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+    if (ts10.isExportDeclaration(statement)) {
+      const target = statement.moduleSpecifier && ts10.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
       if (target)
         targets.add(target);
       if (!statement.exportClause) {
         if (target)
           wildcard.add(target);
-      } else if (ts5.isNamedExports(statement.exportClause)) {
+      } else if (ts10.isNamedExports(statement.exportClause)) {
         for (const element of statement.exportClause.elements)
           named.add(element.name.text);
-      } else if (ts5.isNamespaceExport(statement.exportClause)) {
+      } else if (ts10.isNamespaceExport(statement.exportClause)) {
         named.add(statement.exportClause.name.text);
       }
       continue;
@@ -15526,9 +15999,9 @@ function extractTypeScriptModuleExports(source, filePath = "module.ts") {
     const declarationName2 = exportedDeclarationName(statement);
     if (declarationName2)
       named.add(declarationName2);
-    if (ts5.isVariableStatement(statement) && ts5.getModifiers(statement)?.some((modifier) => modifier.kind === ts5.SyntaxKind.ExportKeyword)) {
+    if (ts10.isVariableStatement(statement) && ts10.getModifiers(statement)?.some((modifier) => modifier.kind === ts10.SyntaxKind.ExportKeyword)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (ts5.isIdentifier(declaration.name))
+        if (ts10.isIdentifier(declaration.name))
           named.add(declaration.name.text);
       }
     }
@@ -15593,6 +16066,8 @@ export {
   extractReactRouterRoutes,
   extractEcmaScriptModuleExports,
   ecmaScriptLanguage,
+  componentPropsName,
+  componentBindingDefaults,
   TypeScriptPlugin,
   EXTRACT_TS_COVERAGE_TIER,
   EXTRACT_TS_CAPABILITIES