@c4a/extract-ts 0.7.4 → 0.7.8

package/index.js

@@ -12532,6 +12532,753 @@ var detectEntries = async (manifest, fs) => {
   };
 };
 
+// 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);
+  }
+  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`);
+      }
+    }
+  }
+  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;
+}
+
+// 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: () => `
+`
+  };
+  const program = ts5.createProgram([...sources.keys()], options, host);
+  for (const source of sources.values())
+    input.symbols.push(...runtimeRegistrations(source), ...federationContracts(source));
+  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));
@@ -12555,7 +13302,17 @@ var relationSourceSchema = exports_external.enum([
 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()
+  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),
@@ -12566,6 +13323,14 @@ var symbolInfoSchema = exports_external.lazy(() => exports_external.object({
   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(),
@@ -12580,6 +13345,7 @@ 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),
@@ -12860,6 +13626,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);
@@ -12941,6 +13709,10 @@ function extractionResultToEvidenceAdapterResult(extraction, invocation) {
     }
     const facts = [];
     if (coverageFile.disposition === "analyzed" && fileInfo) {
+      const source = invocation.source_files?.[normalizedPath2];
+      if (invocation.source_files !== undefined && source === undefined) {
+        throw new TypeError(`Analyzed file ${normalizedPath2} has no scoped source text`);
+      }
       facts.push(fact2({
         sourceRef: invocation.authorized_scope.source_ref,
         moduleRef: invocation.module_ref,
@@ -12948,7 +13720,11 @@ function extractionResultToEvidenceAdapterResult(extraction, invocation) {
         qualifiedItemPath: "file",
         kind: "source-file",
         signature: { path: normalizedPath2, language: fileInfo.language },
-        payload: fileInfo,
+        payload: source === undefined ? fileInfo : {
+          ...fileInfo,
+          line: 1,
+          endLine: source.split(/\r\n|\r|\n/u).length
+        },
         denominator: ownsDenominators ? "eligible-file" : "none"
       }));
       facts.push(fact2({
@@ -13692,27 +14468,27 @@ 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) => {
   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] === "&") {
@@ -13721,7 +14497,7 @@ var treeSitterCompatibleJsxSource = (sourceFile, source) => {
         }
       }
     }
-    ts.forEachChild(node2, visit2);
+    ts6.forEachChild(node2, visit2);
   };
   visit2(sourceFile);
   return changed ? characters.join("") : source;
@@ -13752,25 +14528,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);
@@ -13779,20 +14555,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)) {
@@ -13801,9 +14577,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) {
@@ -13815,7 +14591,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 {
@@ -13825,7 +14601,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 };
@@ -13835,7 +14611,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",
@@ -13844,10 +14620,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;
@@ -13881,430 +14657,192 @@ 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 });
         continue;
       }
-      const direct = requireCall(declaration.initializer);
-      const source = direct ? staticStringValue(direct.arguments[0]) : null;
-      if (!source || !ts2.isObjectBindingPattern(declaration.name))
-        continue;
-      for (const element of declaration.name.elements) {
-        if (!ts2.isIdentifier(element.name))
-          continue;
-        const importedName = element.propertyName?.getText(sourceFile) ?? element.name.text;
-        bindings.push({ localName: element.name.text, source, importedName, line });
-      }
-    }
-  }
-  return bindings;
-};
-var collectDynamicDiagnostics = (sourceFile) => {
-  const diagnostics = [];
-  const visit2 = (node2) => {
-    if (ts2.isCallExpression(node2) && ts2.isIdentifier(node2.expression) && node2.expression.text === "require") {
-      if (staticStringValue(node2.arguments[0]) === null) {
-        const location = nodeLocation(sourceFile, node2);
-        diagnostics.push({
-          code: "dynamic-commonjs-require",
-          severity: "error",
-          file: sourceFile.fileName,
-          line: location.line,
-          column: location.column
-        });
-      }
-    }
-    if (ts2.isCallExpression(node2) && isUnsupportedExportMutationCall(node2)) {
-      const location = nodeLocation(sourceFile, node2);
-      diagnostics.push({
-        code: "unsupported-commonjs-export-form",
-        severity: "error",
-        file: sourceFile.fileName,
-        line: location.line,
-        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 (isCommonJsTarget && commonJsExportTarget(node2.left) === null) {
-          const location = nodeLocation(sourceFile, node2.left);
-          diagnostics.push({
-            code: "dynamic-commonjs-export",
-            severity: "error",
-            file: sourceFile.fileName,
-            line: location.line,
-            column: location.column
-          });
-        }
-      }
-    }
-    ts2.forEachChild(node2, visit2);
-  };
-  visit2(sourceFile);
-  return diagnostics;
-};
-var analyzeCommonJsModule = (source, filePath) => {
-  const sourceFile = createEcmaScriptSourceFile(source, filePath);
-  const bindings = collectBindings(sourceFile);
-  const bindingMap = new Map(bindings.map((binding) => [binding.localName, binding]));
-  const result = {
-    bindings,
-    exports: [],
-    wildcardSources: [],
-    syntheticDeclarations: [],
-    diagnostics: collectDynamicDiagnostics(sourceFile)
-  };
-  for (const statement of sourceFile.statements) {
-    if (!ts2.isExpressionStatement(statement) || !ts2.isBinaryExpression(statement.expression))
-      continue;
-    const assignment = statement.expression;
-    if (assignment.operatorToken.kind !== ts2.SyntaxKind.EqualsToken)
-      continue;
-    const target = commonJsExportTarget(assignment.left);
-    if (!target)
-      continue;
-    const line = nodeLocation(sourceFile, assignment).line;
-    if (target.kind === "named") {
-      if (!pushExport(result, target.exportedName, assignment.right, line, bindingMap, sourceFile)) {
-        appendUnsupportedExportDiagnostic(result, sourceFile, assignment.right);
-      }
-      continue;
-    }
-    const directRequire = requireReference(assignment.right);
-    if (directRequire?.importedName === "*") {
-      result.wildcardSources.push(directRequire.source);
-      continue;
-    }
-    if (ts2.isObjectLiteralExpression(assignment.right)) {
-      for (const property of assignment.right.properties) {
-        if (ts2.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 (name) {
-            if (!pushExport(result, name, property.initializer, line, bindingMap, sourceFile)) {
-              appendUnsupportedExportDiagnostic(result, sourceFile, property.initializer);
-            }
-          } else {
-            appendUnsupportedExportDiagnostic(result, sourceFile, property);
-          }
-          continue;
-        }
-        if (ts2.isMethodDeclaration(property) && property.name && ts2.isIdentifier(property.name)) {
-          const location = nodeLocation(sourceFile, property);
-          result.syntheticDeclarations.push({
-            name: property.name.text,
-            kind: "function",
-            line: location.line,
-            endLine: location.endLine,
-            params: property.parameters.map((parameter) => parameter.name.getText(sourceFile))
-          });
-          result.exports.push({
-            exportedName: property.name.text,
-            localName: property.name.text,
-            line
-          });
-          continue;
-        }
-        appendUnsupportedExportDiagnostic(result, sourceFile, property);
-      }
-      continue;
-    }
-    if (ts2.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")
+      const direct = requireCall(declaration.initializer);
+      const source = direct ? staticStringValue(direct.arguments[0]) : null;
+      if (!source || !ts7.isObjectBindingPattern(declaration.name))
         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 });
-        }
+      for (const element of declaration.name.elements) {
+        if (!ts7.isIdentifier(element.name))
+          continue;
+        const importedName = element.propertyName?.getText(sourceFile) ?? element.name.text;
+        bindings.push({ localName: element.name.text, source, importedName, line });
       }
     }
   }
   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);
+var collectDynamicDiagnostics = (sourceFile) => {
+  const diagnostics = [];
+  const visit2 = (node2) => {
+    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({
+          code: "dynamic-commonjs-require",
+          severity: "error",
+          file: sourceFile.fileName,
+          line: location.line,
+          column: location.column
+        });
+      }
     }
-    for (const binding of commonJs.bindings) {
-      importBindings.set(binding.localName, {
-        source: binding.source,
-        importedName: binding.importedName
+    if (ts7.isCallExpression(node2) && isUnsupportedExportMutationCall(node2)) {
+      const location = nodeLocation(sourceFile, node2);
+      diagnostics.push({
+        code: "unsupported-commonjs-export-form",
+        severity: "error",
+        file: sourceFile.fileName,
+        line: location.line,
+        column: location.column
       });
     }
-    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
+    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({
+            code: "dynamic-commonjs-export",
+            severity: "error",
+            file: sourceFile.fileName,
+            line: location.line,
+            column: location.column
           });
         }
-        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;
+    }
+    ts7.forEachChild(node2, visit2);
+  };
+  visit2(sourceFile);
+  return diagnostics;
+};
+var analyzeCommonJsModule = (source, filePath) => {
+  const sourceFile = createEcmaScriptSourceFile(source, filePath);
+  const bindings = collectBindings(sourceFile);
+  const bindingMap = new Map(bindings.map((binding) => [binding.localName, binding]));
+  const result = {
+    bindings,
+    exports: [],
+    wildcardSources: [],
+    syntheticDeclarations: [],
+    diagnostics: collectDynamicDiagnostics(sourceFile)
+  };
+  for (const statement of sourceFile.statements) {
+    if (!ts7.isExpressionStatement(statement) || !ts7.isBinaryExpression(statement.expression))
+      continue;
+    const assignment = statement.expression;
+    if (assignment.operatorToken.kind !== ts7.SyntaxKind.EqualsToken)
+      continue;
+    const target = commonJsExportTarget(assignment.left);
+    if (!target)
+      continue;
+    const line = nodeLocation(sourceFile, assignment).line;
+    if (target.kind === "named") {
+      if (!pushExport(result, target.exportedName, assignment.right, line, bindingMap, sourceFile)) {
+        appendUnsupportedExportDiagnostic(result, sourceFile, assignment.right);
       }
-      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 directRequire = requireReference(assignment.right);
+    if (directRequire?.importedName === "*") {
+      result.wildcardSources.push(directRequire.source);
+      continue;
+    }
+    if (ts7.isObjectLiteralExpression(assignment.right)) {
+      for (const property of assignment.right.properties) {
+        if (ts7.isShorthandPropertyAssignment(property)) {
+          pushExport(result, property.name.text, property.name, line, bindingMap, sourceFile);
+          continue;
         }
-        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)
+        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);
+            }
+          } else {
+            appendUnsupportedExportDiagnostic(result, sourceFile, property);
+          }
           continue;
-        const match = traced.find((item) => item.exportedName === parsed.localName);
-        if (!match)
+        }
+        if (ts7.isMethodDeclaration(property) && property.name && ts7.isIdentifier(property.name)) {
+          const location = nodeLocation(sourceFile, property);
+          result.syntheticDeclarations.push({
+            name: property.name.text,
+            kind: "function",
+            line: location.line,
+            endLine: location.endLine,
+            params: property.parameters.map((parameter) => parameter.name.getText(sourceFile))
+          });
+          result.exports.push({
+            exportedName: property.name.text,
+            localName: property.name.text,
+            line
+          });
           continue;
-        exportsList.push({
-          exportedName: parsed.exportedName,
-          localName: match.localName,
-          declarationFile: match.declarationFile
-        });
+        }
+        appendUnsupportedExportDiagnostic(result, sourceFile, property);
       }
+      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) : [];
+    if (ts7.isIdentifier(assignment.right)) {
+      const binding = bindingMap.get(assignment.right.text);
+      if (binding?.importedName === "*") {
+        result.wildcardSources.push(binding.source);
+        continue;
       }
-    }));
-    state.inFlight.delete(filePath);
-    return uniqueExports(exportsList);
-  })();
-  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()
-  };
+      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/symbolExtractorAst.ts
+// 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_TYPES2 = new Set([
   "function_declaration",
   "class_declaration",
@@ -14313,296 +14851,243 @@ 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));
     }
-  }
-  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);
+  for (const child of root.namedChildren) {
+    if (DECLARATION_TYPES2.has(child.type)) {
+      register(child);
       continue;
     }
-    const name = member.childForFieldName("name")?.text ?? member.namedChildren[0]?.text;
-    if (!name)
+    if (child.type !== "export_statement")
       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);
+    const declaration = child.namedChildren.find((node2) => DECLARATION_TYPES2.has(node2.type));
+    if (declaration) {
+      register(declaration);
+    }
   }
-  return values.length > 0 ? values : undefined;
+  return declarations;
 };
-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;
+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 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 [];
+    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) : [];
+      }
+    }));
+    state.inFlight.delete(filePath);
+    return uniqueExports(exportsList);
+  })();
+  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;
   }
@@ -14610,21 +15095,21 @@ 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;
   }
@@ -14635,7 +15120,7 @@ var collectStaticCallRelations = (source, filePath, importBindings) => {
   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);
@@ -14643,7 +15128,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;
@@ -14778,10 +15263,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, {
@@ -14807,7 +15292,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) => {
@@ -14815,7 +15300,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,
@@ -14990,13 +15476,13 @@ var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
     }
   }
   for (const child of root.namedChildren) {
-    if (DECLARATION_TYPES2.has(child.type)) {
+    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_TYPES2.has(node2.type));
+    const declaration = child.namedChildren.find((node2) => DECLARATION_TYPES.has(node2.type));
     if (declaration) {
       analyzeDeclaration(declaration, filePath, declarations, importBindings, relations);
     }
@@ -15006,7 +15492,7 @@ var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
   return {
     declarations,
     importBindings,
-    relations,
+    relations: relations.map((relation) => ({ ...relation, file: filePath })),
     lines: countLines(source),
     disposition: "analyzed",
     diagnostics: []
@@ -15022,6 +15508,7 @@ var relationIdentity = (relation) => JSON.stringify([
   relation.grounding,
   relation.confidence,
   relation.source,
+  relation.file ?? null,
   relation.line ?? null
 ]);
 var uniqueRelations = (relations) => {
@@ -15061,14 +15548,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]
       });
     }
   }
@@ -15090,34 +15582,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,
@@ -15195,10 +15660,15 @@ class TypeScriptPlugin {
     }
   }
   async extractSymbolsInScope(entries, analysisPaths, fs) {
-    const packageInfo = this.#lastDetection?.package;
-    if (!packageInfo) {
-      throw new Error("TypeScriptPlugin.extractSymbolsInScope requires detectEntries to run first");
-    }
+    const detectedPackage = this.#lastDetection?.package;
+    if (!detectedPackage && entries.length > 0) {
+      throw new Error("TypeScriptPlugin.extractSymbolsInScope requires detectEntries before using package entries");
+    }
+    const packageInfo = detectedPackage ?? {
+      name: "unknown-package",
+      kind: "lib" /* Lib */,
+      language: packageLanguage(analysisPaths)
+    };
     try {
       return await extractSymbols(entries, fs, {
         packageInfo,
@@ -15211,20 +15681,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;
 }
@@ -15233,37 +15703,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)
@@ -15292,13 +15762,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;
   }
@@ -15307,36 +15777,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];
@@ -15346,8 +15816,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") {
@@ -15362,7 +15832,7 @@ function navigateTarget(node2, sourceFile) {
         }
       }
     }
-    ts4.forEachChild(child, visit2);
+    ts9.forEachChild(child, visit2);
   };
   visit2(node2);
   return target;
@@ -15379,12 +15849,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;
 }
@@ -15426,7 +15896,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"));
@@ -15442,13 +15912,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;
@@ -15461,30 +15931,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;
@@ -15495,17 +15965,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;
@@ -15513,9 +15983,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);
       }
     }
@@ -15580,6 +16050,8 @@ export {
   extractReactRouterRoutes,
   extractEcmaScriptModuleExports,
   ecmaScriptLanguage,
+  componentPropsName,
+  componentBindingDefaults,
   TypeScriptPlugin,
   EXTRACT_TS_COVERAGE_TIER,
   EXTRACT_TS_CAPABILITIES